From 0de9f653b94f3df4e8fa901438b768c66f77ce31 Mon Sep 17 00:00:00 2001 From: Relintai Date: Sat, 16 Mar 2024 20:56:52 +0100 Subject: [PATCH] Mass renamed godot to pandemonium. --- README.md | 22 +- about/complying_with_licenses.md | 28 +- about/docs_changelog.md | 8 +- about/faq.md | 250 +++++++++--------- about/introduction.md | 32 +-- about/list_of_features.md | 38 +-- about/release_policy.md | 52 ++-- about/troubleshooting.md | 26 +- .../best_practices_for_engine_contributors.md | 12 +- .../contributing/bisecting_regressions.md | 44 +-- .../contributing/bug_triage_guidelines.md | 32 +-- community/contributing/building_the_manual.md | 12 +- .../class_reference_writing_guidelines.md | 20 +- .../contributing/code_style_guidelines.md | 44 +-- community/contributing/content_guidelines.md | 10 +- .../contributing_to_the_documentation.md | 36 +-- .../contributing/cpp_usage_guidelines.md | 12 +- .../contributing/docs_writing_guidelines.md | 8 +- .../contributing/documentation_guidelines.md | 34 +-- .../editor_and_docs_localization.md | 54 ++-- community/contributing/index.md | 10 +- community/contributing/pr_workflow.md | 44 +-- .../contributing/testing_pull_requests.md | 6 +- .../updating_the_class_reference.md | 24 +- community/contributing/ways_to_contribute.md | 52 ++-- community/tutorials.md | 18 +- .../compiling/compiling_for_android.md | 44 +-- .../compiling/compiling_for_ios.md | 16 +- .../compiling/compiling_for_osx.md | 30 +-- .../compiling/compiling_for_uwp.md | 34 +-- .../compiling/compiling_for_web.md | 18 +- .../compiling/compiling_for_windows.md | 54 ++-- .../compiling/compiling_for_x11.md | 24 +- .../compiling_with_script_encryption_key.md | 10 +- .../cross-compiling_for_ios_on_linux.md | 14 +- .../compiling/getting_source.md | 20 +- .../introduction_to_the_buildsystem.md | 52 ++-- .../compiling/optimizing_for_size.md | 8 +- .../cpp/binding_to_external_libraries.md | 46 ++-- .../cpp/common_engine_methods_and_macros.md | 16 +- .../cpp/configuring_an_ide/android_studio.md | 6 +- .../cpp/configuring_an_ide/clion.md | 20 +- .../cpp/configuring_an_ide/code_blocks.md | 16 +- .../cpp/configuring_an_ide/index.md | 6 +- .../cpp/configuring_an_ide/kdevelop.md | 10 +- .../cpp/configuring_an_ide/qt_creator.md | 14 +- .../cpp/configuring_an_ide/visual_studio.md | 14 +- .../configuring_an_ide/visual_studio_code.md | 24 +- .../cpp/configuring_an_ide/xcode.md | 22 +- engine_development/cpp/core_types.md | 40 +-- engine_development/cpp/custom_audiostreams.md | 16 +- .../cpp/custom_godot_servers.md | 26 +- .../cpp/custom_modules_in_cpp.md | 52 ++-- .../cpp/custom_resource_format_loaders.md | 26 +- engine_development/cpp/index.md | 12 +- .../cpp/introduction_to_godot_development.md | 14 +- engine_development/cpp/macos_debug.md | 4 +- engine_development/cpp/object_class.md | 22 +- engine_development/cpp/using_cpp_profilers.md | 28 +- engine_development/cpp/variant_class.md | 14 +- engine_development/editor/creating_icons.md | 12 +- .../editor/editor_style_guide.md | 6 +- .../introduction_to_editor_development.md | 38 +-- engine_development/file_formats/index.md | 2 +- engine_development/file_formats/tscn.md | 20 +- index.md | 28 +- modules/entity_spell_system.md | 26 +- modules/layered_tile_maps/using_tilemaps.md | 2 +- modules/layered_tile_maps/using_tilesets.md | 12 +- modules/mesh_data_resource.md | 18 +- modules/mesh_utils.md | 18 +- modules/props.md | 18 +- modules/props_2d.md | 18 +- modules/rtile_map.md | 10 +- modules/skeleton_editor.md | 16 +- modules/terraman.md | 24 +- modules/terraman_2d.md | 24 +- modules/texture_packer.md | 20 +- modules/thread_pool.md | 18 +- modules/ui_extensions.md | 20 +- modules/voxelman.md | 24 +- tutorials/first_2d_game/01.project_setup.md | 2 +- tutorials/first_2d_game/02.player_scene.md | 4 +- .../first_2d_game/03.coding_the_player.md | 8 +- .../first_2d_game/05.the_main_game_scene.md | 2 +- tutorials/first_2d_game/07.finishing-up.md | 4 +- tutorials/first_2d_game/index.md | 16 +- tutorials/first_3d_game/01.game_setup.md | 8 +- tutorials/first_3d_game/02.player_input.md | 6 +- tutorials/first_3d_game/04.mob_scene.md | 2 +- tutorials/first_3d_game/06.jump_and_squash.md | 4 +- .../first_3d_game/08.score_and_replay.md | 8 +- .../first_3d_game/09.adding_animations.md | 4 +- tutorials/first_3d_game/going_further.md | 12 +- tutorials/first_3d_game/index.md | 6 +- .../introduction/first_look_at_the_editor.md | 10 +- .../introduction/godot_design_philosophy.md | 58 ++-- tutorials/introduction/index.md | 12 +- .../introduction/introduction_to_godot.md | 34 +-- .../introduction/key_concepts_overview.md | 14 +- .../introduction/learning_new_features.md | 26 +- tutorials/step_by_step/index.md | 2 +- tutorials/step_by_step/instancing.md | 18 +- tutorials/step_by_step/nodes_and_scenes.md | 16 +- .../step_by_step/scripting_first_script.md | 28 +- tutorials/step_by_step/scripting_languages.md | 50 ++-- .../step_by_step/scripting_player_input.md | 12 +- tutorials/step_by_step/signals.md | 20 +- usage/2d/2d_lights_and_shadows.md | 22 +- usage/2d/2d_meshes.md | 4 +- usage/2d/2d_movement.md | 4 +- usage/2d/2d_sprite_animation.md | 4 +- usage/2d/2d_transforms.md | 2 +- usage/2d/custom_drawing_in_2d.md | 14 +- usage/2d/particle_systems_2d.md | 4 +- usage/2d/using_tilemaps.md | 4 +- usage/3d/3d_rendering_limitations.md | 10 +- usage/3d/3d_text.md | 4 +- usage/3d/baked_lightmaps.md | 8 +- usage/3d/csg_tools.md | 16 +- usage/3d/environment_and_post_processing.md | 22 +- usage/3d/high_dynamic_range.md | 4 +- usage/3d/introduction_to_3d.md | 22 +- usage/3d/lights_and_shadows.md | 2 +- usage/3d/occluders.md | 2 +- .../portals/advanced_room_and_portal_usage.md | 8 +- usage/3d/portals/editing_rooms_and_portals.md | 14 +- .../first_steps_with_rooms_and_portals.md | 4 +- .../introduction_to_rooms_and_portals.md | 6 +- usage/3d/portals/rooms_and_portals_example.md | 2 +- .../using_objects_in_rooms_and_portals.md | 4 +- usage/3d/procedural_geometry/arraymesh.md | 6 +- usage/3d/procedural_geometry/index.md | 8 +- usage/3d/reflection_probes.md | 2 +- usage/3d/spatial_material.md | 32 +-- usage/3d/using_transforms.md | 8 +- usage/animation/2d_skeletons.md | 10 +- usage/animation/animation_tree.md | 14 +- usage/animation/cutout_animation.md | 14 +- usage/animation/introduction.md | 42 +-- usage/animation/playing_videos.md | 14 +- .../escn_exporter/animation.md | 6 +- usage/assets_pipeline/escn_exporter/index.md | 12 +- usage/assets_pipeline/escn_exporter/lights.md | 10 +- .../assets_pipeline/escn_exporter/material.md | 16 +- usage/assets_pipeline/escn_exporter/mesh.md | 2 +- .../assets_pipeline/escn_exporter/physics.md | 4 +- .../assets_pipeline/escn_exporter/skeleton.md | 8 +- usage/assets_pipeline/exporting_3d_scenes.md | 10 +- usage/assets_pipeline/import_process.md | 14 +- .../importing_audio_samples.md | 6 +- usage/assets_pipeline/importing_images.md | 22 +- usage/assets_pipeline/importing_scenes.md | 70 ++--- .../assets_pipeline/importing_translations.md | 10 +- usage/audio/audio_buses.md | 16 +- usage/audio/audio_streams.md | 4 +- usage/audio/recording_with_microphone.md | 4 +- usage/audio/sync_with_audio.md | 4 +- .../autoloads_versus_internal_nodes.md | 8 +- usage/best_practices/data_preferences.md | 22 +- usage/best_practices/godot_interfaces.md | 12 +- usage/best_practices/godot_notifications.md | 10 +- usage/best_practices/index.md | 6 +- .../introduction_best_practices.md | 10 +- usage/best_practices/node_alternatives.md | 4 +- usage/best_practices/project_organization.md | 14 +- usage/best_practices/scene_organization.md | 4 +- usage/best_practices/scenes_versus_scripts.md | 4 +- .../best_practices/version_control_systems.md | 12 +- .../best_practices/what_are_godot_classes.md | 6 +- usage/editor/command_line_tutorial.md | 80 +++--- usage/editor/default_key_mapping.md | 4 +- usage/editor/external_editor.md | 10 +- usage/editor/index.md | 2 +- usage/editor/managing_editor_features.md | 12 +- usage/editor/using_the_web_editor.md | 18 +- usage/export/android_custom_build.md | 8 +- .../changing_application_icon_for_windows.md | 18 +- usage/export/exporting_basics.md | 34 +-- usage/export/exporting_for_android.md | 22 +- .../export/exporting_for_dedicated_servers.md | 20 +- usage/export/exporting_for_ios.md | 34 +-- usage/export/exporting_for_linux.md | 6 +- usage/export/exporting_for_macos.md | 16 +- usage/export/exporting_for_uwp.md | 4 +- usage/export/exporting_for_web.md | 20 +- usage/export/exporting_for_windows.md | 8 +- usage/export/exporting_pcks.md | 16 +- usage/export/exporting_projects.md | 32 +-- usage/export/feature_tags.md | 4 +- usage/export/one-click_deploy.md | 6 +- usage/export/running_on_macos.md | 6 +- usage/i18n/internationalizing_games.md | 16 +- usage/i18n/localization_using_gettext.md | 30 +-- .../inputs/controllers_gamepads_joysticks.md | 36 +-- usage/inputs/handling_quit_requests.md | 2 +- usage/inputs/input_examples.md | 8 +- usage/inputs/inputevent.md | 6 +- usage/inputs/mouse_and_input_coordinates.md | 2 +- usage/io/background_loading.md | 2 +- usage/io/binary_serialization_api.md | 6 +- usage/io/data_paths.md | 60 ++--- usage/math/beziers_and_curves.md | 2 +- usage/math/img/tutovec10.svg | 2 +- usage/math/img/tutovec11.svg | 2 +- usage/math/img/tutovec12.svg | 2 +- usage/math/img/tutovec14.svg | 2 +- usage/math/matrices_and_transforms.md | 46 ++-- usage/math/random_number_generation.md | 8 +- usage/math/vector_math.md | 14 +- usage/math/vectors_advanced.md | 8 +- usage/navigation/navigation_debug_tools.md | 4 +- .../navigation/navigation_introduction_2d.md | 12 +- .../navigation/navigation_introduction_3d.md | 10 +- .../navigation_using_navigationmaps.md | 2 +- .../navigation_using_navigationmeshes.md | 2 +- .../navigation_using_navigationservers.md | 2 +- usage/navigation/real_time_navigation_3d.md | 4 +- usage/networking/high_level_multiplayer.md | 34 +-- usage/networking/http_client_class.md | 4 +- usage/networking/http_request_class.md | 2 +- usage/networking/ssl_certificates.md | 4 +- usage/networking/webrtc.md | 8 +- usage/networking/websocket.md | 8 +- usage/performance/batching.md | 20 +- usage/performance/cpu_optimization.md | 34 +-- usage/performance/general_optimization.md | 8 +- usage/performance/gpu_optimization.md | 12 +- usage/performance/index.md | 6 +- .../performance/optimizing_3d_performance.md | 12 +- usage/performance/threads/thread_safe_apis.md | 6 +- .../threads/using_multiple_threads.md | 2 +- usage/performance/using_servers.md | 14 +- .../animating_thousands_of_fish.md | 4 +- usage/physics/collision_shapes_3d.md | 14 +- .../physics_interpolation_introduction.md | 14 +- .../using_physics_interpolation.md | 6 +- usage/physics/kinematic_character_2d.md | 6 +- usage/physics/physics_introduction.md | 6 +- usage/physics/ragdoll_system.md | 8 +- usage/physics/ray-casting.md | 6 +- usage/physics/soft_body.md | 2 +- usage/physics/using_area_2d.md | 4 +- usage/physics/using_kinematic_body_2d.md | 8 +- .../android/android_in_app_purchases.md | 20 +- usage/platform/android/android_plugin.md | 54 ++-- usage/platform/consoles.md | 22 +- usage/platform/customizing_html5_shell.md | 20 +- usage/platform/html5_shell_classref.md | 22 +- usage/platform/ios/ios_plugin.md | 22 +- usage/platform/ios/plugins_for_ios.md | 8 +- .../platform/mobile_rendering_limitations.md | 2 +- usage/plugins/editor/import_plugins.md | 16 +- usage/plugins/editor/installing_plugins.md | 6 +- .../editor/making_main_screen_plugins.md | 4 +- usage/plugins/editor/making_plugins.md | 12 +- usage/plugins/editor/spatial_gizmos.md | 2 +- usage/plugins/editor/visual_shader_plugins.md | 2 +- usage/plugins/running_code_in_the_editor.md | 2 +- usage/rendering/jitter_stutter.md | 6 +- usage/rendering/multiple_resolutions.md | 26 +- usage/rendering/viewports.md | 12 +- usage/scripting/creating_script_templates.md | 10 +- usage/scripting/cross_language_scripting.md | 8 +- usage/scripting/debug/debugger_panel.md | 2 +- .../debug/overview_of_debugging_tools.md | 4 +- usage/scripting/evaluating_expressions.md | 6 +- usage/scripting/filesystem.md | 34 +-- usage/scripting/gdscript/gdscript_advanced.md | 12 +- usage/scripting/gdscript/gdscript_basics.md | 16 +- usage/scripting/gdscript/gdscript_exports.md | 2 +- .../gdscript/gdscript_format_string.md | 8 +- .../scripting/gdscript/gdscript_styleguide.md | 14 +- usage/scripting/gdscript/static_typing.md | 26 +- usage/scripting/gdscript/warning_system.md | 2 +- usage/scripting/groups.md | 2 +- .../scripting/idle_and_physics_processing.md | 2 +- usage/scripting/index.md | 4 +- usage/scripting/overridable_functions.md | 8 +- usage/scripting/pausing_games.md | 4 +- usage/scripting/resources.md | 26 +- usage/scripting/scene_tree.md | 8 +- usage/scripting/singletons_autoload.md | 6 +- usage/shaders/advanced_postprocessing.md | 10 +- .../converting_glsl_to_godot_shaders.md | 52 ++-- usage/shaders/custom_postprocessing.md | 10 +- usage/shaders/index.md | 2 +- usage/shaders/introduction_to_shaders.md | 24 +- usage/shaders/making_trees.md | 2 +- usage/shaders/screen-reading_shaders.md | 8 +- usage/shaders/shader_materials.md | 6 +- .../shader_reference/canvas_item_shader.md | 8 +- .../shader_reference/shading_language.md | 22 +- .../shader_reference/spatial_shader.md | 16 +- usage/shaders/shaders_style_guide.md | 14 +- usage/shaders/using_viewport_as_texture.md | 2 +- usage/shaders/your_first_shader/index.md | 2 +- .../your_first_shader/your_first_2d_shader.md | 14 +- .../your_first_shader/your_first_3d_shader.md | 22 +- .../your_second_3d_shader.md | 10 +- usage/ui/control_node_gallery.md | 2 +- usage/ui/custom_gui_controls.md | 2 +- usage/ui/gui_containers.md | 6 +- usage/ui/gui_navigation.md | 2 +- usage/ui/gui_skinning.md | 14 +- usage/ui/gui_using_theme_editor.md | 6 +- usage/ui/index.md | 2 +- 307 files changed, 2384 insertions(+), 2384 deletions(-) diff --git a/README.md b/README.md index 6e52e49..b394a98 100644 --- a/README.md +++ b/README.md @@ -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. diff --git a/about/complying_with_licenses.md b/about/complying_with_licenses.md index 1bf0b75..25e69a1 100644 --- a/about/complying_with_licenses.md +++ b/about/complying_with_licenses.md @@ -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). diff --git a/about/docs_changelog.md b/about/docs_changelog.md index a324690..8f1461d 100644 --- a/about/docs_changelog.md +++ b/about/docs_changelog.md @@ -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: diff --git a/about/faq.md b/about/faq.md index 7dd1800..1e3faa8 100644 --- a/about/faq.md +++ b/about/faq.md @@ -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 )`. diff --git a/about/introduction.md b/about/introduction.md index 3f28a94..4b7529c 100644 --- a/about/introduction.md +++ b/about/introduction.md @@ -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! diff --git a/about/list_of_features.md b/about/list_of_features.md index 4d74ed2..e42fe02 100644 --- a/about/list_of_features.md +++ b/about/list_of_features.md @@ -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. diff --git a/about/release_policy.md b/about/release_policy.md index de6da1c..24faf15 100644 --- a/about/release_policy.md +++ b/about/release_policy.md @@ -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. diff --git a/about/troubleshooting.md b/about/troubleshooting.md index 1932a73..e5be515 100644 --- a/about/troubleshooting.md +++ b/about/troubleshooting.md @@ -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 diff --git a/community/contributing/best_practices_for_engine_contributors.md b/community/contributing/best_practices_for_engine_contributors.md index f81ab32..c42c806 100644 --- a/community/contributing/best_practices_for_engine_contributors.md +++ b/community/contributing/best_practices_for_engine_contributors.md @@ -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. diff --git a/community/contributing/bisecting_regressions.md b/community/contributing/bisecting_regressions.md index b99c60a..dce930a 100644 --- a/community/contributing/bisecting_regressions.md +++ b/community/contributing/bisecting_regressions.md @@ -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 ``` -Compile Godot. This assumes you've set up a build environment: +Compile Pandemonium. This assumes you've set up a build environment: ``` # 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= -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: diff --git a/community/contributing/bug_triage_guidelines.md b/community/contributing/bug_triage_guidelines.md index 4d6d3c7..b3000a1 100644 --- a/community/contributing/bug_triage_guidelines.md +++ b/community/contributing/bug_triage_guidelines.md @@ -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 diff --git a/community/contributing/building_the_manual.md b/community/contributing/building_the_manual.md index 8d5e3d5..943c031 100644 --- a/community/contributing/building_the_manual.md +++ b/community/contributing/building_the_manual.md @@ -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 diff --git a/community/contributing/class_reference_writing_guidelines.md b/community/contributing/class_reference_writing_guidelines.md index 8524800..d28e8ea 100644 --- a/community/contributing/class_reference_writing_guidelines.md +++ b/community/contributing/class_reference_writing_guidelines.md @@ -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. - https://docs.godotengine.org/en/latest/tutorials/2d/custom_drawing_in_2d.html - https://github.com/godotengine/godot-demo-projects/tree/master/2d + https://docs.pandemoniumengine.org/en/latest/tutorials/2d/custom_drawing_in_2d.html + https://github.com/pandemoniumengine/pandemonium-demo-projects/tree/master/2d @@ -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: - `` @@ -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/ )`. diff --git a/community/contributing/code_style_guidelines.md b/community/contributing/code_style_guidelines.md index 73969b9..37fedbb 100644 --- a/community/contributing/code_style_guidelines.md +++ b/community/contributing/code_style_guidelines.md @@ -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 `. 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 diff --git a/community/contributing/content_guidelines.md b/community/contributing/content_guidelines.md index e117289..29c4a9c 100644 --- a/community/contributing/content_guidelines.md +++ b/community/contributing/content_guidelines.md @@ -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. diff --git a/community/contributing/contributing_to_the_documentation.md b/community/contributing/contributing_to_the_documentation.md index 3d60434..49f2508 100644 --- a/community/contributing/contributing_to_the_documentation.md +++ b/community/contributing/contributing_to_the_documentation.md @@ -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. diff --git a/community/contributing/cpp_usage_guidelines.md b/community/contributing/cpp_usage_guidelines.md index 06683d6..34a80c5 100644 --- a/community/contributing/cpp_usage_guidelines.md +++ b/community/contributing/cpp_usage_guidelines.md @@ -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. diff --git a/community/contributing/docs_writing_guidelines.md b/community/contributing/docs_writing_guidelines.md index dba06e5..dda8053 100644 --- a/community/contributing/docs_writing_guidelines.md +++ b/community/contributing/docs_writing_guidelines.md @@ -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 diff --git a/community/contributing/documentation_guidelines.md b/community/contributing/documentation_guidelines.md index 6459e06..b381c58 100644 --- a/community/contributing/documentation_guidelines.md +++ b/community/contributing/documentation_guidelines.md @@ -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. diff --git a/community/contributing/editor_and_docs_localization.md b/community/contributing/editor_and_docs_localization.md index 2e1b94f..d227efd 100644 --- a/community/contributing/editor_and_docs_localization.md +++ b/community/contributing/editor_and_docs_localization.md @@ -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)`. diff --git a/community/contributing/index.md b/community/contributing/index.md index 2ec8b45..31cea2b 100644 --- a/community/contributing/index.md +++ b/community/contributing/index.md @@ -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. diff --git a/community/contributing/pr_workflow.md b/community/contributing/pr_workflow.md index 905214d..6453301 100644 --- a/community/contributing/pr_workflow.md +++ b/community/contributing/pr_workflow.md @@ -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. ``` diff --git a/community/contributing/testing_pull_requests.md b/community/contributing/testing_pull_requests.md index a04ae0f..ab8b392 100644 --- a/community/contributing/testing_pull_requests.md +++ b/community/contributing/testing_pull_requests.md @@ -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: diff --git a/community/contributing/updating_the_class_reference.md b/community/contributing/updating_the_class_reference.md index e2bef6b..2ff22df 100644 --- a/community/contributing/updating_the_class_reference.md +++ b/community/contributing/updating_the_class_reference.md @@ -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`. diff --git a/community/contributing/ways_to_contribute.md b/community/contributing/ways_to_contribute.md index 004c32b..bb267d7 100644 --- a/community/contributing/ways_to_contribute.md +++ b/community/contributing/ways_to_contribute.md @@ -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. diff --git a/community/tutorials.md b/community/tutorials.md index 1f077f8..6e02351 100644 --- a/community/tutorials.md +++ b/community/tutorials.md @@ -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 )` diff --git a/engine_development/compiling/compiling_for_android.md b/engine_development/compiling/compiling_for_android.md index 9d89b7e..1fe5ab5 100644 --- a/engine_development/compiling/compiling_for_android.md +++ b/engine_development/compiling/compiling_for_android.md @@ -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, diff --git a/engine_development/compiling/compiling_for_ios.md b/engine_development/compiling/compiling_for_ios.md index 955a965..4204268 100644 --- a/engine_development/compiling/compiling_for_ios.md +++ b/engine_development/compiling/compiling_for_ios.md @@ -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 diff --git a/engine_development/compiling/compiling_for_osx.md b/engine_development/compiling/compiling_for_osx.md index add5db6..4f87490 100644 --- a/engine_development/compiling/compiling_for_osx.md +++ b/engine_development/compiling/compiling_for_osx.md @@ -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 diff --git a/engine_development/compiling/compiling_for_uwp.md b/engine_development/compiling/compiling_for_uwp.md index 26ad1c7..0566e70 100644 --- a/engine_development/compiling/compiling_for_uwp.md +++ b/engine_development/compiling/compiling_for_uwp.md @@ -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. diff --git a/engine_development/compiling/compiling_for_web.md b/engine_development/compiling/compiling_for_web.md index 915cca1..a6a1b55 100644 --- a/engine_development/compiling/compiling_for_web.md +++ b/engine_development/compiling/compiling_for_web.md @@ -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 diff --git a/engine_development/compiling/compiling_for_windows.md b/engine_development/compiling/compiling_for_windows.md index 5733656..cecaf3c 100644 --- a/engine_development/compiling/compiling_for_windows.md +++ b/engine_development/compiling/compiling_for_windows.md @@ -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\\ + %USERPROFILE%\AppData\Roaming\Pandemonium\templates\\ ``` 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. diff --git a/engine_development/compiling/compiling_for_x11.md b/engine_development/compiling/compiling_for_x11.md index a851ed0..0071bf8 100644 --- a/engine_development/compiling/compiling_for_x11.md +++ b/engine_development/compiling/compiling_for_x11.md @@ -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. diff --git a/engine_development/compiling/compiling_with_script_encryption_key.md b/engine_development/compiling/compiling_with_script_encryption_key.md index 39e539e..2b568de 100644 --- a/engine_development/compiling/compiling_with_script_encryption_key.md +++ b/engine_development/compiling/compiling_with_script_encryption_key.md @@ -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. ``` diff --git a/engine_development/compiling/cross-compiling_for_ios_on_linux.md b/engine_development/compiling/cross-compiling_for_ios_on_linux.md index 048d5e5..f59f79a 100644 --- a/engine_development/compiling/cross-compiling_for_ios_on_linux.md +++ b/engine_development/compiling/cross-compiling_for_ios_on_linux.md @@ -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. diff --git a/engine_development/compiling/getting_source.md b/engine_development/compiling/getting_source.md index 4aa1308..e5c162f 100644 --- a/engine_development/compiling/getting_source.md +++ b/engine_development/compiling/getting_source.md @@ -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 )`. diff --git a/engine_development/compiling/introduction_to_the_buildsystem.md b/engine_development/compiling/introduction_to_the_buildsystem.md index 3511432..389d650 100644 --- a/engine_development/compiling/introduction_to_the_buildsystem.md +++ b/engine_development/compiling/introduction_to_the_buildsystem.md @@ -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..[opt].[tools/debug].[extension] + pandemonium..[opt].[tools/debug].[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 /platform/android/java` and select the `settings.gradle` file. +- Navigate to `/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 Open** from the top menu. -- Navigate to `/platform/android/java/nativeSrcsConfigs` (the +- Navigate to `/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. diff --git a/engine_development/cpp/configuring_an_ide/code_blocks.md b/engine_development/cpp/configuring_an_ide/code_blocks.md index 01715b5..b11010f 100644 --- a/engine_development/cpp/configuring_an_ide/code_blocks.md +++ b/engine_development/cpp/configuring_an_ide/code_blocks.md @@ -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 )`. diff --git a/engine_development/cpp/configuring_an_ide/index.md b/engine_development/cpp/configuring_an_ide/index.md index d6d0d50..29505c8 100644 --- a/engine_development/cpp/configuring_an_ide/index.md +++ b/engine_development/cpp/configuring_an_ide/index.md @@ -1,10 +1,10 @@ Configuring an IDE ================== -We assume that you have already `cloned ( https://github.com/godotengine/godot )` -and `compiled /bin` folder. The name depends on your build configuration, - e.g. `godot.x11.tools.64` for 64-bit X11 platform with `tools` enabled. + the `/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 )`. diff --git a/engine_development/cpp/configuring_an_ide/qt_creator.md b/engine_development/cpp/configuring_an_ide/qt_creator.md index 6bc7740..9cf9560 100644 --- a/engine_development/cpp/configuring_an_ide/qt_creator.md +++ b/engine_development/cpp/configuring_an_ide/qt_creator.md @@ -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 `/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 `/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 )`. diff --git a/engine_development/cpp/configuring_an_ide/visual_studio.md b/engine_development/cpp/configuring_an_ide/visual_studio.md index f3a2f79..c52e043 100644 --- a/engine_development/cpp/configuring_an_ide/visual_studio.md +++ b/engine_development/cpp/configuring_an_ide/visual_studio.md @@ -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 )`. diff --git a/engine_development/cpp/configuring_an_ide/visual_studio_code.md b/engine_development/cpp/configuring_an_ide/visual_studio_code.md index 62152e1..19e585d 100644 --- a/engine_development/cpp/configuring_an_ide/visual_studio_code.md +++ b/engine_development/cpp/configuring_an_ide/visual_studio_code.md @@ -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 )`. diff --git a/engine_development/cpp/configuring_an_ide/xcode.md b/engine_development/cpp/configuring_an_ide/xcode.md index 0db37dd..fabc75b 100644 --- a/engine_development/cpp/configuring_an_ide/xcode.md +++ b/engine_development/cpp/configuring_an_ide/xcode.md @@ -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 )`. diff --git a/engine_development/cpp/core_types.md b/engine_development/cpp/core_types.md index b1a080f..fb426f7 100644 --- a/engine_development/cpp/core_types.md +++ b/engine_development/cpp/core_types.md @@ -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 )` diff --git a/engine_development/cpp/custom_audiostreams.md b/engine_development/cpp/custom_audiostreams.md index d617c7d..93898c3 100644 --- a/engine_development/cpp/custom_audiostreams.md +++ b/engine_development/cpp/custom_audiostreams.md @@ -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 )` diff --git a/engine_development/cpp/custom_godot_servers.md b/engine_development/cpp/custom_godot_servers.md index 510098d..8d30acb 100644 --- a/engine_development/cpp/custom_godot_servers.md +++ b/engine_development/cpp/custom_godot_servers.md @@ -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 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 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_Owneradd_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 ------------- diff --git a/engine_development/cpp/custom_modules_in_cpp.md b/engine_development/cpp/custom_modules_in_cpp.md index 1d545a6..fb20d01 100644 --- a/engine_development/cpp/custom_modules_in_cpp.md +++ b/engine_development/cpp/custom_modules_in_cpp.md @@ -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 --doctool . + user@host:~/pandemonium/bin$ ./bin/ --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. diff --git a/engine_development/cpp/custom_resource_format_loaders.md b/engine_development/cpp/custom_resource_format_loaders.md index 64e93ff..ba3ca01 100644 --- a/engine_development/cpp/custom_resource_format_loaders.md +++ b/engine_development/cpp/custom_resource_format_loaders.md @@ -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 #include - 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" ] diff --git a/engine_development/cpp/index.md b/engine_development/cpp/index.md index 5718ba9..2443f14 100644 --- a/engine_development/cpp/index.md +++ b/engine_development/cpp/index.md @@ -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 diff --git a/engine_development/cpp/introduction_to_godot_development.md b/engine_development/cpp/introduction_to_godot_development.md index 93fbb3f..eb22d34 100644 --- a/engine_development/cpp/introduction_to_godot_development.md +++ b/engine_development/cpp/introduction_to_godot_development.md @@ -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 ``` diff --git a/engine_development/cpp/macos_debug.md b/engine_development/cpp/macos_debug.md index 02c6ac4..d9d0c79 100644 --- a/engine_development/cpp/macos_debug.md +++ b/engine_development/cpp/macos_debug.md @@ -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 diff --git a/engine_development/cpp/object_class.md b/engine_development/cpp/object_class.md index a5e3866..24dd902 100644 --- a/engine_development/cpp/object_class.md +++ b/engine_development/cpp/object_class.md @@ -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 )` diff --git a/engine_development/cpp/using_cpp_profilers.md b/engine_development/cpp/using_cpp_profilers.md index 2c5e547..9750cc1 100644 --- a/engine_development/cpp/using_cpp_profilers.md +++ b/engine_development/cpp/using_cpp_profilers.md @@ -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 ** in the dropdown that appears. + **Filter Module to ** 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) diff --git a/engine_development/cpp/variant_class.md b/engine_development/cpp/variant_class.md index 5ace9e5..63e84f4 100644 --- a/engine_development/cpp/variant_class.md +++ b/engine_development/cpp/variant_class.md @@ -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 )` diff --git a/engine_development/editor/creating_icons.md b/engine_development/editor/creating_icons.md index 237074e..dcce2df 100644 --- a/engine_development/editor/creating_icons.md +++ b/engine_development/editor/creating_icons.md @@ -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 )` diff --git a/engine_development/editor/editor_style_guide.md b/engine_development/editor/editor_style_guide.md index 199d274..a2969fe 100644 --- a/engine_development/editor/editor_style_guide.md +++ b/engine_development/editor/editor_style_guide.md @@ -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 diff --git a/engine_development/editor/introduction_to_editor_development.md b/engine_development/editor/introduction_to_editor_development.md index da36328..4b7d9cf 100644 --- a/engine_development/editor/introduction_to_editor_development.md +++ b/engine_development/editor/introduction_to_editor_development.md @@ -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 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) diff --git a/modules/props_2d.md b/modules/props_2d.md index 4e4ba90..8e768d3 100644 --- a/modules/props_2d.md +++ b/modules/props_2d.md @@ -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) diff --git a/modules/rtile_map.md b/modules/rtile_map.md index d4d8704..d5ddce9 100644 --- a/modules/rtile_map.md +++ b/modules/rtile_map.md @@ -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) diff --git a/modules/skeleton_editor.md b/modules/skeleton_editor.md index a791d47..6177a8c 100644 --- a/modules/skeleton_editor.md +++ b/modules/skeleton_editor.md @@ -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) diff --git a/modules/terraman.md b/modules/terraman.md index 2ada903..3e306aa 100644 --- a/modules/terraman.md +++ b/modules/terraman.md @@ -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: diff --git a/modules/terraman_2d.md b/modules/terraman_2d.md index ceca0e8..6edca87 100644 --- a/modules/terraman_2d.md +++ b/modules/terraman_2d.md @@ -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: diff --git a/modules/texture_packer.md b/modules/texture_packer.md index 68b84be..f8b9c18 100644 --- a/modules/texture_packer.md +++ b/modules/texture_packer.md @@ -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 diff --git a/modules/thread_pool.md b/modules/thread_pool.md index 2e28b87..52eafbb 100644 --- a/modules/thread_pool.md +++ b/modules/thread_pool.md @@ -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) diff --git a/modules/ui_extensions.md b/modules/ui_extensions.md index 809fde2..0810283 100644 --- a/modules/ui_extensions.md +++ b/modules/ui_extensions.md @@ -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) diff --git a/modules/voxelman.md b/modules/voxelman.md index 92ada63..89091f0 100644 --- a/modules/voxelman.md +++ b/modules/voxelman.md @@ -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: diff --git a/tutorials/first_2d_game/01.project_setup.md b/tutorials/first_2d_game/01.project_setup.md index 3c598da..1125946 100644 --- a/tutorials/first_2d_game/01.project_setup.md +++ b/tutorials/first_2d_game/01.project_setup.md @@ -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) diff --git a/tutorials/first_2d_game/02.player_scene.md b/tutorials/first_2d_game/02.player_scene.md index e14e69e..47e44ad 100644 --- a/tutorials/first_2d_game/02.player_scene.md +++ b/tutorials/first_2d_game/02.player_scene.md @@ -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 diff --git a/tutorials/first_2d_game/03.coding_the_player.md b/tutorials/first_2d_game/03.coding_the_player.md index a081366..6c51b7c 100644 --- a/tutorials/first_2d_game/03.coding_the_player.md +++ b/tutorials/first_2d_game/03.coding_the_player.md @@ -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 diff --git a/tutorials/first_2d_game/05.the_main_game_scene.md b/tutorials/first_2d_game/05.the_main_game_scene.md index f317a5f..4dc6ef5 100644 --- a/tutorials/first_2d_game/05.the_main_game_scene.md +++ b/tutorials/first_2d_game/05.the_main_game_scene.md @@ -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 diff --git a/tutorials/first_2d_game/07.finishing-up.md b/tutorials/first_2d_game/07.finishing-up.md index 66e511b..0afa035 100644 --- a/tutorials/first_2d_game/07.finishing-up.md +++ b/tutorials/first_2d_game/07.finishing-up.md @@ -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. diff --git a/tutorials/first_2d_game/index.md b/tutorials/first_2d_game/index.md index aef3bf0..6f509b7 100644 --- a/tutorials/first_2d_game/index.md +++ b/tutorials/first_2d_game/index.md @@ -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