diff --git a/docs/about/complying-with-licenses.md b/docs/about/complying-with-licenses.md
index cd25cf7..ec7a9c3 100644
--- a/docs/about/complying-with-licenses.md
+++ b/docs/about/complying-with-licenses.md
@@ -11,18 +11,17 @@ Orchestrator is created and distributed under the Apache License, Version 2.0 requirements.
+These requirements not only require the inclusion of the above text, but all source files of the original work must retain the original copyright and license preamble.
+Additionally, any changes made to the source must be recorded in the headers of the source files.
+While changes are not required to be submitted back to the original project, they're welcomed!
:::
-:::info
+:::tip
Your game does not need to be under the same license as Orchestrator.
-You are free to release your Godot projects under any license and to create commercial games with this plug-in.
+You are free to release your Godot project under any license, and to create commercial games with this plug-in.
:::
### Inclusion
-The license does not specify specifically how it must be included in your game, so there are a number of options that you can freely use depending on how you distribute or wish to share license information with your users.
-These are the most common approaches and you only need to implement one, not all.
+The license does not specify specifically how it must be included in your game.
+There are a number of options that you can freely use depending on how you distribute or wish to share license information with your users.
+These are the most common approaches, and you only need to implement one, not all.
#### Credits screen
-Include the above license text somewhere in the credits screen.
+Include the above [License text](#requirements-text) somewhere in the credits screen.
It can be at the bottom after showing the rest of the credits.
Most studios use this approach with open source licenses.
@@ -66,17 +69,21 @@ Most studios use this approach with open source licenses.
Some games have a special menu (often in the settings) to display licenses.
This menu is typically accessed with a button called `Third-party Licenses` or `Open Source Licenses`.
+If your game uses such a style, include the above [License text](#requirements-text) there.
#### Accompanying file
-If the game is distributed on desktop platforms, a file that contains the license text can be added to the software that is installed on the user's PC.
+If the game is distributed on desktop platforms, a file that contains the [License text](#requirements-text) can be added to the software that is installed on the user's PC.
#### Printed manual
-If the game includes printed manuals, license text can be included there.
+If the game includes printed manuals, [License text](#requirements-text) can be included there.
### Third-party licenses
+Orchestrator is free and open-source, and its built using other free and open-source technologies.
+Each of those technologies have their own respective licenses, and thanks to them, Orchestrator is possible.
+
#### Godot GDExtension (godot-cpp)
```text
Copyright (c) 2017-present Godot Engine contributors.
diff --git a/docs/about/credits.md b/docs/about/credits.md
index f46307c..d1364bf 100644
--- a/docs/about/credits.md
+++ b/docs/about/credits.md
@@ -4,6 +4,8 @@ sidebar_position: 7
# Credits
+These are assets used by this documentation, but are from other sources.
+
| Image Names | Attribution | License |
|:--------------------------------------------------|:------------------------------------------------------|:------------------------------------------------------------------------------------------------------------------|
| scripting_first_script_rotating_godot.gif | Juan Linietsky, Ariel Manzur and the Godot community. | LICENSE.txt |
diff --git a/docs/about/index.md b/docs/about/index.md
index 073c921..97f279e 100644
--- a/docs/about/index.md
+++ b/docs/about/index.md
@@ -11,7 +11,7 @@ Orchestrator's documentation is available in various languages and versions.
Expand the language or version selector in the top navigation panel to see the possible values.
:::
-Welcome to the official documentation of Orchestrator, the ultimate Visual Scripting solution specific designed for Godot platform 4.2 and later.
+Welcome to the official documentation of Orchestrator, the ultimate Visual Scripting solution specific designed for Godot platform.
If you are new to this documentation, we recommend that you read the [introduction page](./introduction.md) to get an overview of what this documentation has to offer.
The table of contents in the sidebar should let you easily access the documentation for your topic of interest.
@@ -22,4 +22,11 @@ Orchestrator is an open source project developed by Vahera Studios, LLC in colla
The documentation team can always use feedback and help to improve tutorials, class reference guides, and more.
If you don't understand something, or cannot find what you are looking for in the docs, help us make the documentation better by letting us know!
-Submit an issue or pull request on the GitHub repository or help translate the documentation into other languages.
\ No newline at end of file
+Submit an issue or pull request on the GitHub repository or help translate the documentation into other languages.
+
+## Offline documentation
+
+To browse the documentation offline, you can clone the GitHub repository.
+
+This documentation is built using Docusaurus, using React and Node.JS.
+Simply install the Node.JS package manager `npm`, and you can easily build and serve this documentation locally.
\ No newline at end of file
diff --git a/docs/about/introduction.md b/docs/about/introduction.md
index 80d0038..930226b 100644
--- a/docs/about/introduction.md
+++ b/docs/about/introduction.md
@@ -20,7 +20,7 @@ In case you have trouble with one of the tutorials or your project, you can alwa
## About Orchestrator
Every game emerges from a single idea, and the creation of a game involves many moving parts.
-Godot Orchestrator's goal is to provide a series of easy to use, highly customizable features to create game logic, interactions, and supporting logic using visual scripting rather than traditional text-based code.
+Orchestrator's goal is to provide a series of easy to use, highly customizable features to create game logic, interactions, and supporting logic using visual scripting rather than traditional text-based code.
Orchestrator is completely free and open source under the Apache License, Version 2.0.
The game you create is yours, down to the last line of code.
@@ -31,7 +31,7 @@ This plug-in's development is fully independent and entirely community-driven, g
This documentation is organized into several sections:
* **About** contains this introduction, as well as information about the plug-in, its history, licensing, authors, and more.
-It also contains the [Frequently asked questions](../about/faq)
+It also contains the [Frequently asked questions](../about/faq) section, helping answer some of the most common questions.
* **Getting Started** contains all necessary information on using the plug-in to make games.
It starts with a **Step by Step** tutorial which should be the entry point for all new users.
@@ -47,6 +47,9 @@ It also has sections intended for advanced users and contributors, with informat
* **Community** is dedicated to the life of the Orchestrator plug-in's community.
It refers to various community outlets and discords, and contains a list of recommended tutorials and materials beyond this documentation.
+* The **Script Node Reference** documents each Orchestrator visual script node type, how you can use them, their purpose, and how to configure them.
+This is where you should check if you don't understand a specific node or are unsure how to locate a specific node or feature.
+
In addition to this documentation, you may also want to take a look at the various Orchestrator example projects.
## About this documentation
diff --git a/docs/about/release-policy.md b/docs/about/release-policy.md
index b7cd991..0c0d88d 100644
--- a/docs/about/release-policy.md
+++ b/docs/about/release-policy.md
@@ -9,7 +9,7 @@ The description below provides a general idea of what to expect, but what may ac
## Versioning
-Orchestrator loosely follows Semantic Versioning with a `major.minor.patch` version system.
+Orchestrator loosely follows Semantic Versioning with a `major.minor.patch` version system.
* The `major` version is incremented when major compatibility breakages happen which imply significant porting work to move projects from one major version to another.
@@ -65,8 +65,8 @@ We recommend using Orchestrator 2.0 for all new projects, as the Orchestrator 1.
The Orchestrator contributors do not work under any strict deadlines, but we strive to publish minor releases relatively frequently.
We generally try and focus on a three-month cadence for a minor release, starting at the first month of the calendar quarter and releasing a stable version of that minor release toward the end of the quarter.
-For example, Orchestrator 2.0 entered pre-release review for testing at the start of January 2024, and eventually was released stable in March.
-In addition, Orchestrator 2.1 entered development in early April and is planned for a stable release sometime toward the end of June 2024.
+For example, Orchestrator 2.0 entered pre-release review for testing at the start of January 2024, was released stable in March 2024.
+In addition, Orchestrator 2.1 entered development in early April and is planned for a stable release toward the end of June 2024.
## What are the criteria for compatibility across versions?
diff --git a/docs/getting-started/introduction/first-look-at-the-plugin.md b/docs/getting-started/introduction/first-look-at-the-plugin.md
index f119660..c73455e 100644
--- a/docs/getting-started/introduction/first-look-at-the-plugin.md
+++ b/docs/getting-started/introduction/first-look-at-the-plugin.md
@@ -13,16 +13,41 @@ You access the main workspace of the plug-in by clicking on the tab labeled **Or
### Graph view
+Initially, the main workspace is empty, only showing the file list.
+This is because no `Orchestration` resources have been opened.
+By either creating a new orchestration using `File > New Orchestration`, or opening an existing orchestration, the main workspace will include other widgets.
+
-Initially, the main workspace will be mostly empty because no orchestration resources have been opened.
-By either creating a new orchestration, using `File > New Orchestration`, or opening an existing orchestration, the main workspace will include a large graph canvas in the center of the main panel, and a set of panels to the right called the **Component** view.
+In the above example, an orchestration has been opened.
+To the left is the **Graph** canvas where you place visual script nodes to create logic.
+At the top of the **Graph**, there is a tab bar, where you can quickly navigate between different **Graph** components or user-defined **Function**s.
+
+On the right is the **Component** view, where high-level components can be added.
### Component view
+The **Component** view is where you can quickly add, rename, and remove various components from the orchestration.
+
-The **Component** view is where you can quickly add, rename, and remove various components from the orchestration.
+* The **Graph** section always defines at least one graph called **EventGraph**.
+This is where you will define all your interactions with the Godot engine to handle overrides, such as when your script receives *input* or updates each game tick.
+
+* The **Functions** section allows for defining user-defined functions.
+User-defined functions are a great way to not only expose functionality to the outside of your script, but to also organize your code so that the visual scripts do not become cluttered.
+
+* The **Macros** section is currently unimplemented, and will be enabled in a future patch.
+
+* The **Variables** section allows for creating unique named objects for storing values.
+Variables are associated with a specific Godot type can can either be publicly accessible or scoped to the script.
+A variable will be publicly accessible if it has the icon.
+The variable is not publicly accessible if it has the icon.
+
+* The **Signals** section is for user-defined signals, allowing outside observers to connect and be notified when you emit a signal.
+
+To add a new **Component** type to the `Orchestration`, use the button.
+Additionally, for **Functions**, you can also override several Godot built-in virtual functions using the button.
### All actions dialog
@@ -33,6 +58,21 @@ To begin adding logic to your script, use the right-mouse button to open the **A
This dialog is where you can search for specific nodes that you wish to add to the graph.
To add a node, either select the choice and press the **Add** button or simply press **Enter**.
+Actions are grouped into the following high-level categories:
+
+* Functions that you can call on the object, denoted with the icon.
+* Properties that you can access, denoted with the icon.
+* Signals you can connect and react to, denoted with the icon.
+* Overridable functions, denoted with the icon.
+* And Orchestrator script nodes, denoted with the icon.
+
+:::tip
+The icon identifies an action that is currently not a favorite.
+If you use a specific action frequently, it's recommended that you click the button to make it a favorite.
+Favorites are listed at the top of the **All Actions** dialog and will have a new icon.
+If you later wish to unfavorite an action, simply click the button.
+:::
+
:::tip
Right-clicking the graph canvas opens the **All Actions** dialog using the script's base type as the context.
If you drag from a visual script node's pin and release the mouse, the **All Actions** dialog will be opened using the context of the pin.
@@ -45,9 +85,12 @@ A visual script node is the building block of an orchestration, that you connect
-Script nodes consist of two types of pins, execution or control flow pins, identified by the white arrows, and data pins which are identified by colored dots.
-The pins on the left side of a script node are inputs, they provide a way for you to pass execution flow or data into the node.
-The pins on the right side of a script node are outputs, they provide a way for you to pass execution flow to another node, or output data for another node to consume.
+Script nodes consist of two types of pins, execution or control flow pins, and data pins which are identified by colored dots.
+
+* **Inputs**
+The pins on the left side of a script node are called inputs, which allow you to pass data or control flow to the node.
+* **Outputs**
+The pins on the right side a script node are called outputs, which allow you to pass data or control to another node.
Visual script nodes can be added to an orchestration using various methods, which include:
@@ -117,28 +160,31 @@ One of the major benefits of Orchestrator is it recognizes data elements that ar
The following drag-n-drop options exist:
-- Drag a scene node from the **Scene** dock to get a reference to that scene node in the script.
-- Drag a property from the **Inspector** dock to access either a **Get** or a **Set** for the specific property.
-- Drag a resource from the **FileSystem** dock to either obtain its path or to create a **Preload** node for the resource.
+- Drag a scene node from the **Scene** view to get a reference to that scene node in the script.
+- Drag a property from the **Inspector** view to access either a **Get** or a **Set** for the specific property.
+- Drag a resource from the **FileSystem** view to either obtain its path or to create a **Preload** node for the resource.
### Multi-node operations
Bulk operations improves efficiency, and having access to such tools makes working with visual scripting less tedious.
You can use the **Left Mouse Button** to click on the graph and begin to drag to select multiple script nodes.
-With multiple node selected, you can cut (`Ctrl+X`), copy (`Ctrl+C`), and paste (`Ctrl+V`) as needed.
+With multiple node selected, you can cut (`Ctrl+X`), copy (`Ctrl+C`), and paste (`Ctrl+V`) as needed.
:::tip
-You can also quickly duplicate script nodes using `Ctrl+D`, which is a shortcut for copy-n-paste.
+You can also quickly duplicate script nodes using `Ctrl+D`, which is a shortcut for copy-n-paste.
:::
### Undo and redo
At this time, Orchestrator does not officially support Undo/Redo operations in the Godot Editor.
-It is currently under development, and is planned for a future release.
+
+:::info
+This feature is currently under development and is planned for a future release.
+:::
## Integrated help
-You can access the documentation related to any visual script node by selecting the node, right-click, and selecting the **View Documentation** option.
+You can access the documentation related to any visual script node by selecting the node, right-click, and selecting the **View Documentation** option.
This automatically redirects the Editor's main view to the Editor Help window, where the script, associated Godot method, or other related object's help will be shown.
diff --git a/docs/getting-started/introduction/index.md b/docs/getting-started/introduction/index.md
index 8d52a31..d7134dc 100644
--- a/docs/getting-started/introduction/index.md
+++ b/docs/getting-started/introduction/index.md
@@ -11,6 +11,7 @@ We will introduce the plug-in's most essential concepts, showcase the in-editor
* [Introduction to Orchestrator](introduction-to-orchestrator)
* [Overview of key concepts](key_concepts)
+* [Installation Guide](installation-guide)
* [First look at the plug-in](first-look-at-the-plugin)
* [Learning new features](learning-new-features)
* [Orchestrator's design philosophy](orchestrator-design-philosophy)
\ No newline at end of file
diff --git a/docs/getting-started/introduction/installation-guide.md b/docs/getting-started/introduction/installation-guide.md
index 320e08d..a9783e4 100644
--- a/docs/getting-started/introduction/installation-guide.md
+++ b/docs/getting-started/introduction/installation-guide.md
@@ -6,7 +6,7 @@ sidebar_position: 3
There two ways to install the plug-in:
-* Using the Godot Asset Library in the Godot Editor.
+* Using the Godot Asset Library in the Godot Editor.
* Downloading the plug-in from our GitHub repository.
In this section, we'll cover how to use both.
@@ -15,7 +15,7 @@ In this section, we'll cover how to use both.
The Godot Editor has a built-in asset library feature, which allows users to search, download, and install Godot plug-ins, tools, and assets directly from their online asset catalog.
-To access the **Asset Library**, we'll use the **AssetLib** tab at the top of the Godot Editor.
+To access the **Asset Library**, we'll use the **AssetLib** tab at the top of the Godot Editor.
@@ -32,15 +32,20 @@ When the download finishes, you'll be prompted to **Configure Asset Before Insta
-Very important, **Uncheck the `Ignore asset root`** option.
+Uncheck the `Ignore asset root` option.
+:::warning
+Failing the uncheck this option will not install the plug-in correctly into your project.
+:::
-Finally, click the **Install** button to install the plug-in into your project.
+Finally, click the **Install** button, installing the plug-in into the `res://addons/orchestrator` directory.
+After installation, the Godot Editor will prompt you to restart.
-:::important
-If the installation is successful, the plug-in will be installed into `res://addons/orchestrator`.
-Additionally, the Godot Editor will prompt you to restart.
+:::tip
+There is currently an issue with the Godot Editor with loading textures used by GDExtension plug-ins.
+The plug-in will be loaded before the textures are imported, causing the textures to not render initially or appear broken in some scenarios.
+Restarting the Godot Editor one final time fixes the issue.
:::
## Download from GitHub
@@ -65,3 +70,9 @@ This should create a directory path like `\addons\orchestrator`.
Once the files have been installed, focusing the Godot Editor will request to restart.
Simply follow the prompt, restarting Godot, and the plug-in should be active when the editor restarts.
+
+:::tip
+There is currently an issue with the Godot Editor with loading textures used by GDExtension plug-ins.
+The plug-in will be loaded before the textures are imported, causing the textures to not render initially or appear broken in some scenarios.
+Restarting the Godot Editor one final time fixes the issue.
+:::
\ No newline at end of file
diff --git a/docs/getting-started/introduction/introduction-to-orchestrator.md b/docs/getting-started/introduction/introduction-to-orchestrator.md
index e9c7d29..94d0a59 100644
--- a/docs/getting-started/introduction/introduction-to-orchestrator.md
+++ b/docs/getting-started/introduction/introduction-to-orchestrator.md
@@ -4,8 +4,8 @@ sidebar_position: 1
# Introduction to Orchestrator
-This article is to help you figure out whether Orchestrator might be a good fit for you.
-We will introduce some broad features of the plug-in and give you a feel for what is achievable with it while also answering questions such as "what do I need to know to get started?".
+This article is to help you determine if Orchestrator might be a good fit for you.
+We will introduce some broad features of the plug-in and give you a feel for what is achievable while also answering questions such as "what do I need to know to get started?".
This is by no means an exhaustive overview.
We will introduce many more features in this getting started series.
@@ -28,19 +28,23 @@ You can read more in the
You can find many more examples in our GitHub examples repository.
+## How to install the plug-in?
+
+Orchestrator does not ship with the Godot Editor, and instead it must be installed into your Godot project as a plug-in.
+For information on how to install the plug-in into a new project, please read the [Installation Guide](installation-guide).
+
## How does it work and look?
-Orchestrator is a plug-in that must be installed into a new Godot project.
-You can read more information about how to install the plug-in in the [Installation Guide](installation-guide).
-Once installed, the plug-in provides you with an entirely new workspace tab in the main editor viewport to create visual graphs for connecting nodes that represent logical actions, constructing game logic that powers your game.
+Orchestrator provides you with an entirely new workspace tab in the main editor viewport to create visual graphs for connecting nodes that represent logical actions, constructing game logic that powers your game.
@@ -52,19 +56,24 @@ Any project is also evolving, so while we believe the integration is done quite
The Godot engine provides two core programming languages out of the box, `GDScript` and `C#`.
These two languages provide seamless, powerful scripting opportunities in the engine; however, both of these are entirely text-driven.
-An `Orchestration`, or `OrchestratorScript` is another language that is injected into Godot by the Orchestrator plug-in.
-This plug-in is written in C++, the default, most popular language in the gaming industry.
-However, users of Orchestrator do not need to know anything about C++ as the entire engine is built based on visual blocks that are visually combined to create logic.
-These nodes you connect in a visual graph, they're automatically translated into native machine instructions, so that the script runs at optimal speeds under the most taxing game requirements.
+Orchestrator provides a new type of programming language to Godot, to create new script resource types called `Orchestration`s.
+An orchestration, offered called an `OrchestratorScript` or `OScript` for short, is a visual-scripting language where you connect visual blocks together to build games.
+
+Orchestrator's code base is written in C++, the most popular language used in the gaming industry.
+Developers use C++ because it's highly optimized and efficient, which is critical in high-performance games.
+
+However, as a developer using Orchestrator, you aren't required to know C++, or really any type of language syntax.
+The plug-in is designed to connect visual blocks of functionality together to create logic.
+An `Orchestration` is translated automatically to machine instructions at runtime, so that the script runs at optimal speeds under the most taxing game requirements.
-The integration with Godot is based on the Godot GDExtension technology, which is a binding to support running high-performance code written in C and C++ without needing to recompile the engine, and can run seamlessly within the Godot editor or game process space.
+And finally, the plug-in seamlessly integrates with the Godot Editor and Godot Engine thanks to the GDExtension technology, a binding provided by the Godot development team for creating high-performance plug-ins and code in C and C++, that can run inside the Godot Editor or in exported Godot games.
## What do I need to know to use Orchestrator?
Orchestrator is a feature packed plug-in for Godot, with thousands of features.
-Its goal is to abstract away a lot of the technical noise around syntax and specific language features, enabling the developer to conceptualize what they want and to combine high-level nodes by their function to create game logic.
+Its goal is to abstract away a lot of the technical noise around syntax and specific language features, enabling you to conceptualize what you need and to combine high-level behavior nodes to create game logic.
While we try and make the plug-in accessible to the most junior of developers, having a basic understanding programming concepts can help tremendously.
-As we continue to refine the plug-in and find more ways to simplifying design patterns, your input will help shape this effort more than anything else possible.
+As we continue to refine the plug-in and find more ways to simplifying its design, your input will help shape this effort more than anything else possible.
In the next part, you will get an overview of the plug-ins essential concepts.
\ No newline at end of file
diff --git a/docs/getting-started/introduction/key_concepts.md b/docs/getting-started/introduction/key_concepts.md
index 79a4dcb..cca04ed 100644
--- a/docs/getting-started/introduction/key_concepts.md
+++ b/docs/getting-started/introduction/key_concepts.md
@@ -5,73 +5,99 @@ sidebar_position: 2
# Overview of key concepts
Orchestrator is a Godot-plugin that is based on a set of key abstractions.
+
An `Orchestration` is the main resource that you will be creating and managing using the Orchestrator plug-in.
-It represents multiple graphs that contain any number of nodes connected together to build game logic and behavior.
-An orchestration also supports user-defined functions and variables, much like you would see in `GDScript` or `C#`.
-An orchestration is a Godot `Script` type, that can be attached to a node inside the scene tree, that will interact with engine callbacks and signals just like if you had attached a `C#` or `GDScript` file instead.
+It represents a Godot `Script` object that contains one or more graphs with any number of connected nodes.
+
+Orchestrations also support user-defined functions, variables, and signals, much like you would see in `GDScript` or `C#` script.
+Since an orchestration is considered a Godot `Script`, you can attach it to any scene node, and it will be able to interact with the engine just like Godot's text-based script options.
There are **6** major concepts, and we're going to look at them briefly to give you a sense of how the plug-in works.
### Scenes
While scenes are not something specific to Orchestrator, they are the foundation to which Orchestrator stands.
-So it's extremely important to understand what scenes are, how they're used, and why they're important in Godot.
+It's extremely important to understand what scenes are, how they're used, and why they're important in a Godot project.
In Godot, developers break down a game into reusable components, called *scenes*.
+
A scene can literally be anything, a character, a weapon, a menu in the user interface, a single house, an entire level, and the list continues.
-Godot's scene system is designed to be flexible; providing the role of both prefabs (archetypes) or scenes in other engines.
+Godot's scene system is designed to be flexible; providing the role of both prefabs (archetypes) and scenes/levels, terms often used in other engines.
### Nodes
A scene is composed of one or more *nodes*.
-Nodes are Godot's smallest building blocks that you arrange into trees.
+Nodes are Godot's smallest building blocks that you arrange into tree hierarchies.
In this example, it is made up of a `CharacterBody2D` node named "Player", a `Camera2D`, a `Sprite2D`, and a `CollisionShape2D`.
+The `CharacterBody2D` or "Player", is the root of this scene.
+The other nodes are children of the root scene node, which creates a set of node hierarchies in the scene tree.
:::info
The node names end with `2D` because this is a two-dimensional scene; however 3D counterparts end with `3D`.
:::
-If you look closely at the node in the scene called "Player", there is a small icon to the right that resembles a piece of paper.
+If you look closely at the node in the scene called "Player", there is an icon to the right.
This icon signifies that the node has a script attached.
The visual scripts you create with Orchestrator, called `Orchestration`s, are scripts that can be attached to scene nodes.
-When they are attached, a small paper icon like this is shown in the scene view.
+When they are attached, the is shown in the scene view next to the node.
+
+### Graph workspace
+
+The **Graph** is the main workspace where you will spend the vast majority of your time creating orchestrations.
+It is the canvas where you will place nodes, connecting them to create complex behaviors.
+
+
+
+To the right of the **Graph** canvas is what is called the **Component** view.
+The **Component** view is where you can add, rename, and remove a variety of high-level components in an Orchestration.
+
+An `Orchestration` is not restricted to just a single **Graph** workspace.
+You can add multiple graphs using the button at the top of the **Graph** panel in the **Component** view.
+
+In addition, when you add a user-defined function, these will also have their own **Graph** and will be opened in separate tabs.
+In the image above, you can see several tabs for **EventGraph**, **apply_rotation**, and others.
+This technique allows for optimal organization in visual scripts, preventing clutter and *spaghetti* code.
+
+The **Component** view also allows for creating **Variables** and **Signals**.
### Signals
-Godot nodes emit signals when specific events occur.
-Signals allow you to communicate with other parts of the game without hard-wiring them through code.
-This provides a significant amount of flexibility in how you structure scenes, and how you build your orchestration scripts.
+All Godot objects can emit signals, a notification to an observer when a specific event occurs.
-
-
:::info
Signals are Godot's version of the *observer* pattern.
:::
-For example, buttons emit a signal when pressed.
-Other parts of the game, including visual script components, can connect to this signal and run some action in response to the button press, such as transitioning between two menus, starting your game, or even exiting the game.
+Signals allow you to communicate with other parts of the game without creating a hard dependency between two parts of the code.
+This allows for a significant amount of flexibility when building scenes, and how you can construct orchestrations.
-### Graph workspace
+To add a signal to the `Orchestration`, use the **Component** view and click the icon in the **Signals** panel header.
-The **Graph** is the main workspace where you will spend the vast majority of your time creating orchestrations.
-It is the canvas where you will place nodes, connecting them to create complex behaviors.
+Observers can be connected to signals either through code or using the Editor's interface.
+The way to connect a signal to an `Orchestration` is using the Editor's interface.
-
+
+
+Locate the **Node** view, this is in the same dock where you will find the **Inspector** and **History** tab views.
+In the **Node** view, there are two distinct subsections, _Signals_ and _Groups_.
+Make sure that the _Signals_ section is highlighted, as shown above.
-An `Orchestration` is not restricted to just a single **Graph** workspace.
-In fact, you can add multiple graphs using the `[+]` button at the top of the **Graph** panel in the **Component** view.
-In addition, when you add user-defined functions, these too will be rendered in separate tabs in the **Graph** workspace, allowing for optimal organization between subsets of your visual script.
+In this view, signals are represented with the icon next to its name.
+If a signal has any connections, there will be child items listed under the signal, denoted with the icon.
-The **Component** view is the area to the right of the graph workspace, where you define graphs, user-defined functions, variables, and signals.
+For example, the above image shows that the function `_on_area_2d_body_entered()` will be called when the `body_entered` signal is emitted.
+This is an example of creating an `Area2D`, a 2D area trigger, and notifying some observer that an object has entered the trigger's area.
### Variables
-A **Variable** represents a named value that can be assigned a value in the visual script or can be read.
-Variables are useful for passing data between graphs and for maintaining state that is managed by the `Orchestration`.
+A **Variable** represents a named value that can be assigned a value or its value read in the visual script.
+Variables are useful for passing data between different parts of the script, and for maintaining state that is managed by the `Orchestration`.
+
+To add a new variable, use the **Component** view and click the icon in the **Variables** panel header.
diff --git a/docs/getting-started/introduction/orchestrator-design-philosophy.md b/docs/getting-started/introduction/orchestrator-design-philosophy.md
index d41cf6a..aa2f58b 100644
--- a/docs/getting-started/introduction/orchestrator-design-philosophy.md
+++ b/docs/getting-started/introduction/orchestrator-design-philosophy.md
@@ -6,7 +6,10 @@ sidebar_position: 6
Now that you've gotten your feet wet, let's talk about Orchestrator's design.
-**Every visual scripting engine is different and fits different needs**.
+:::important
+Every visual scripting engine is different and fits different needs.
+:::
+
Not only do various visual scripting systems offer a range of features, how those features are designed and interact with the underlying game engine is also unique.
Orchestrator attempts to take some of the best practices and concepts from other visual scripting engines, and incorporates those into a plug-in that works well for Godot.
@@ -17,14 +20,18 @@ We want game developers to be able to use full, visual tools to build game logic
We acknowledge that visual scripting is not for everyone, and we expect that respect to be reciprocated.
It's equally important to understand that there are those who simply struggle to learn text-based languages, and can thrive using visual tools.
-And so it's our goal to provide the same level of tools to those developers that is also available to those who prefer GDScript or C#.
+
+Our mission and prime directive is to provide state-of-the-art tooling, and let you decide if it fits your needs.
+
+Games do not have to be made solely with or without one scripting technology like Orchestrator.
+You can safely mix-n-match, using Orchestrator for certain game aspects and combine GDScript or C# for others.
## Open source
Orchestrator is a fully, open-source code base under the **Apache License 2.0**.
-This means that all the technologies that ship with our plug-in must be Free (as in freedom) as well.
+Anyone can freely use Orchestrator in any type of project, public, commercial, and proprietary as long as you comply with the license requirements.
-Anyone can freely use Orchestrator in any type of project, public, commercial, and proprietary.
+See the [Complying with licenses](../../about/complying-with-licenses) section for details.
## Community-driven
diff --git a/docs/getting-started/step-by-step/index.md b/docs/getting-started/step-by-step/index.md
index fd89d56..0bfdc94 100644
--- a/docs/getting-started/step-by-step/index.md
+++ b/docs/getting-started/step-by-step/index.md
@@ -62,7 +62,7 @@ Lastly, click and drag the icon in the viewport to center it in the game view.
### Creating a new orchestration
-To create and attach a new `Orchestration` to our node, right-click on the `Sprite2D` in the **Scene** view and select **Attach Script**.
+To create and attach a new `Orchestration` to our node, right-click on the `Sprite2D` in the **Scene** view and select ** Attach Script**.
@@ -74,7 +74,7 @@ Click the **Create** button to create the script.
-The Orchestrator **EventGraph** workspace should appear with your `sprite_2d.os` orchestration open.
+The Orchestrator ** EventGraph** workspace should appear with your `sprite_2d.os` orchestration open.
@@ -91,7 +91,7 @@ Let's make it print the text "Hello, world!" to the output bottom panel to get s
Lastly, we need to add a Godot event callback so that our **Print String** node outputs the value.
-1. Press the `Override Godot virtual function` button located at the top right of the **Functions** panel.
+1. Press the button located at the top right of the **Functions** panel.
2. Search or the `Call Init` action.
3. To add the node, either press the **Add** button or simply hit **Enter**.
@@ -134,7 +134,7 @@ To do so, we're going to add two member variables to our Orchestration:
To define the movement speed variable:
-1. Click the `[+]` button to add a new variable in the **Variables** component section.
+1. Click the button to add a new variable in the **Variables** component section.
2. Give the variable the name `speed`, and press enter.
3. Select the variable in the **Component** view to have the **Inspector** display the variable's details.
4. In the **Inspector**, change the `Type` to an `Integer` and assign a default value of `400`.
@@ -143,7 +143,7 @@ To define the movement speed variable:
To define the angular speed variable:
-1. Click the `[+]` button to add a new variable in the **Variables** component section.
+1. Click the button to add a new variable in the **Variables** component section.
2. Give the variable the name `angular_speed`, and press enter.
3. Select the variable in the **Component** view to have the **Inspector** display the variable's details.
4. In the **Inspector**, change the `Type` to an `Float` and assign a default value of `3.14`.
@@ -167,8 +167,8 @@ Most games aim for 60 FPS, although you might find values lower or higher.
We are going to add the **Process Event** node much like we did the **Init Event** node.
-1. Press the `Override Godot virtual function` button on the top-right of the **Functions** panel.
-2. In the **All Actions** dialog, locate the **Call Process Event** node.
+1. Press the button on the top-right of the **Functions** panel.
+2. In the **All Actions** dialog, locate the `Call Process Event` node.
3. To add the node, either press **Add** or simply hit **Enter**.
With the **Process Event** node on the graph, we need to connect logic to this node to perform this computation, but visually:
@@ -266,7 +266,7 @@ This user-defined function will accept the `delta` time in seconds.
To create the user-defined function:
-1. Press the `[+]` button on the top-right of the **Functions** panel in the **Component** view.
+1. Press the button on the top-right of the **Functions** panel in the **Component** view.
2. When prompted for a function name, enter `apply_rotation` and press **Enter**.
3. In the **Inspector** view, adjust the function properties by setting the following properties:
* Set the `Argument Count` to a value of `1`.
@@ -281,7 +281,7 @@ One of the benefits with Orchestrator is that all user-defined functions are org
This helps to declutter large graphs, and serves as a really neat way to organize your code.s
Now, you may wonder how do we get the nodes we created in the **EventGraph** into this user-defined graph.
-Orchestrator supports bulk operations, so we're going to use **Cut** and **Paste** to move that logic.
+Orchestrator supports bulk operations, so we're going to use **Cut** and **Paste** to move that logic.
So at the top of the graph workspace, click the **EventGraph** tab to go back to the main **Graph**.
Left-click anywhere on the graph canvas and select the nodes that are specific to the rotation logic.
@@ -301,7 +301,7 @@ Now to move these nodes to the user-defined function, we're going to first **Cop
:::note
The nodes may have been pasted near the center of the graph.
-You can click the **Toggle the graph minimap** at the top of the graph to quickly find them.
+You can click the **Toggle the graph minimap** at the top of the graph to quickly find them.
Simply drag the selected nodes or the **Function Entry** node together.
:::
@@ -334,7 +334,7 @@ Your **EventGraph** should now look like this:
Now that we have moved the logic for rotation to a user-defined function, the next step is to do the same for **Apply Movement**.
-1. Press the `[+]` button on the top-right of the **Functions** panel in the **Component** view.
+1. Press the button on the top-right of the **Functions** panel in the **Component** view.
2. When prompted for a function name, enter `apply_movement` and press **Enter**.
3. In the **Inspector** view, adjust the function properties by setting the following properties:
* Set the `Argument Count` to a value of `1`.
@@ -404,7 +404,11 @@ We are going to use the `Input` singleton here as we need to know if the player
For turning, we should use a new variable: `direction`.
In the **Component** panel, we're also going to create a new user-defined function to calculate the direction.
-1. Press the `[+]` on the **Functions** panel in the **Component** view.
+#### Calculating the direction
+
+To add the new function, follow these steps:
+
+1. Press the on the **Functions** panel in the **Component** view.
2. Set the new function name as `calculate_direction`.
In this function, what we ultimately want to accomplish is this logic:
@@ -450,7 +454,7 @@ We can duplicate an existing node by using the `Ctrl+D` shortcut.
To duplicate the **Input Action** node:
1. Select the **Input Action** node, if it isn't already selected.
-2. Press the `Ctrl+D` shortcut or right-click and select the **Duplicate** option.
+2. Press the `Ctrl+D` shortcut or right-click and select the **Duplicate** option.
You should now have two **Input Action** nodes, as shown here:
@@ -488,7 +492,7 @@ In our case, we're going to create a **Sequence** node that will have **4** outp
1. Right-click the graph and open the **All Actions** dialog.
2. Search for `Sequence`.
3. Select the `Sequence` option and press **Add** or simply press **Enter**.
-4. In the **Sequence** node, press the `[+]` button so that there are **4** output execution pins.
+4. In the **Sequence** node, press the button so that there are **4** output execution pins.
5. Connect the `Then 0` output execution pin to one of the **Set direction** nodes.
6. In that **Set direction** node, make sure that the `direction` value is `0` (the default).
@@ -522,7 +526,9 @@ The graph for `calculate_direction()` should look like this:
-The last step is to use this function inside our `apply_rotation()`.
+#### Using the direction calculation
+
+The last step is to use the the `calculate_direction` function inside our `apply_rotation` function.
1. Navigate to the `apply_rotation` function.
2. Drag the `calculate_direction` function onto the graph from the **Component** view.
@@ -551,13 +557,15 @@ Now, as nice as this simple game is at this point, we'd like to have better cont
In this section, we're going to adjust how `apply_movement` works, and only have the icon move when the player presses the `Up` arrow key.
This will make the icon easier to control and keep on on the screen.
+#### Calculating the velocity
+
If you recall when we originally designed the `apply_movement` function, we used the following to calculate the `velocity`.
```python title="GDScript"
var velocity = Vector2.UP.rotated(rotation) * speed
```
-Now instead, we want to conditionalize this, having the `velocity` set to `Vector2.ZERO` and only applying the calculation if the player has pressed the `Up` arrow key.
+Now instead, we want to conditionalize this, having the `velocity` set to `Vector2.ZERO`, and only applying the calculation if the player has pressed the `Up` arrow key.
```python title="GDScript"
var velocity = Vector2.ZERO
@@ -567,7 +575,7 @@ if Input.is_action_pressed("ui_up"):
We're going to accomplish this by introducing a new function called `calculate_velocity`.
-1. Press the `[+]` button at the top of the **Functions** panel in the **Component** view.
+1. Press the button at the top of the **Functions** panel in the **Component** view.
2. When asked for a function name, enter `calculate_velocity`.
In this function, we either want to return `Vector2.ZERO` if the player has not pressed the `Up` arrow key, or return the velocity based on the current `rotation` and `speed` values.
@@ -625,6 +633,8 @@ At the end, your graph for `calculate_velocity` should look like this:
+#### Using the velocity calculation
+
With the `calculate_velocity` function done, we need to use this in the `apply_movement` function.
Navigate back to the `apply_movement` function and perform these steps:
diff --git a/docs/nodes/constants.md b/docs/nodes/constants.md
index 15cacc4..184384a 100644
--- a/docs/nodes/constants.md
+++ b/docs/nodes/constants.md
@@ -10,7 +10,7 @@ For example, in mathematics, there are numerous constants called `TAU` and `PI`,
In this section, you will learn what are Orchestrator's constant types, and how to use them.
:::warning
-Constant nodes are considered _experimental_, and may change in the future.
+Constant nodes are considered _experimental_, and may change in the future.
While it is safe to use these in your Orchestrations, they may be replaced by a more consolidated, and user-friendly node in the future.
:::
diff --git a/docs/nodes/dialogue.md b/docs/nodes/dialogue.md
index d1c3c7a..0cc7e1a 100644
--- a/docs/nodes/dialogue.md
+++ b/docs/nodes/dialogue.md
@@ -39,11 +39,11 @@ We will be adding an Orchestrator setting in the future to allow setting a custo
### Non-linear conversation flow
One of the most powerful ways to create immersive RPG conversation is to provide options when interacting with non-player characters, creating responses that are tailored based on the choices selected by the player.
-Orchestrator's **Show Message** node provides for this using the `[+]` button.
+Orchestrator's **Show Message** node provides for this using the button.
To add one or more conversation choices:
-1. Press the `[+]` button to add a conversation choice.
+1. Press the button to add a conversation choice.
2. Add a **Dialogue Choice** node to the graph and wire its output pin to the input pin of the message node's choice.
3. Connect any output logic to that choice's output pin, which will receive the output pulse when the player selects that choice.
diff --git a/docs/nodes/events.md b/docs/nodes/events.md
index ebe1ce7..dc9856e 100644
--- a/docs/nodes/events.md
+++ b/docs/nodes/events.md
@@ -17,7 +17,7 @@ If you want to trigger multiple actions from one event, you will need to string
To add an event to the **Graph**:
-1. Press the `Override a Godot Virtual Function` in the **Functions** section of the **Components** view.
+1. Press the button in the **Functions** section of the **Components** view.
2. Search for the desired Godot event to override in the search box, i.e. `ready`.
3. Press the **Add** button or simply press **Enter**.
diff --git a/docs/nodes/flow-control.md b/docs/nodes/flow-control.md
index d756e4e..ed0b86b 100644
--- a/docs/nodes/flow-control.md
+++ b/docs/nodes/flow-control.md
@@ -32,10 +32,10 @@ It can be removed by unchecking the `Has Default Pin` property in the **Inspecto
1. Select the switch node in the **Graph** to display its properties in the **Inspector** view.
2. Change the **Start Index** to the lowest integer value that you want to check against.
-3. Click on the `[+]` button to add a new *output* pin with the **Start Index** value.
+3. Click on the button to add a new *output* pin with the **Start Index** value.
-Clicking on the `[+]` button will add additional output pins, with the value incremented by 1 each time.
+Clicking on the button will add additional output pins, with the value incremented by 1 each time.
To remove an execution pin, right-click on the pin and select **Remove Pin**.
:::note
@@ -46,7 +46,7 @@ Removing an output execution pin on a **Switch on Integer** node causes any high
1. Select the switch node in the **Graph** to display its properties in the **Inspector** view.
-2. Click on the `[+]` button on the node in the **Graph** to add new *output* pins.
+2. Click on the button on the node in the **Graph** to add new *output* pins.
3. A new expandable section called **Pin Names** will appear in the **Inspector** view.
@@ -205,7 +205,7 @@ In a future Orchestrator update, wires will be controlled by user-driven **Knots
A **Random** node allows specifying one or more output execution pins, and one will be chosen randomly when the node executes.
-To add a new output execution, simply click the `[+]` button to add a new choice output.
+To add a new output execution, simply click the button to add a new choice output.
To remove an output execution, simply right-click the name of the choice and select **Remove Pin** from the context-menu.
| Pin | Description |
@@ -238,7 +238,7 @@ To restrict the **Select** node to a specific Godot type, right-click on the `A`
A **Sequence** node allows the execution of two or more execution chains in sequential order, by first executing the connections of **Then 0**, followed by **Then 1**, and so on until all output connections have been called.
-Additionally, new output connections can be added by pressing the `[+]` button on the graph node.
+Additionally, new output connections can be added by pressing the button on the graph node.
If an output connection should be removed, right-click the output pin name and select **Remove Pin**.
| Pin | Description |
diff --git a/docs/nodes/functions.md b/docs/nodes/functions.md
index 184e7e1..730e098 100644
--- a/docs/nodes/functions.md
+++ b/docs/nodes/functions.md
@@ -25,7 +25,7 @@ We may choose to add this in the future if there is reasonable demand.
To create a Function within an orchestration:
-1. In the **Component** panel, press the `[+]` button in the **Functions** section.
+1. In the **Component** panel, press the button in the **Functions** section.
2. Enter a name for the Function.
@@ -128,7 +128,7 @@ def min(Variant x, Variant y, Variant...) {
```
In this example, the `min` function accepts at a minimum two `Variant` values called **x** and **y**; however, the function may be called with additional `Variant` values if the caller wishes to compute the minimum across more than two values.
-Orchestrator supports variable argument functions, and you can recognize these as they'll have a `[+]` button in the bottom right corner, allowing you to add additional *input* pins to the node.
+Orchestrator supports variable argument functions, and you can recognize these as they'll have a button in the bottom right corner, allowing you to add additional *input* pins to the node.
diff --git a/docs/nodes/input.md b/docs/nodes/input.md
index 5bf8e30..5d26169 100644
--- a/docs/nodes/input.md
+++ b/docs/nodes/input.md
@@ -19,7 +19,7 @@ For example, to define an action called `move_forward` to be triggered when pres
1. Open the `Input Map` tab by navigating the `Project > Project Settings` menu.
2. In the **Add New Action** field, type `move_forward`.
3. Press the `+ Add` button to add the new action to the input map.
-4. In the lower section of the dialog, find the action `move_forward`, and press the `+` button.
+4. In the lower section of the dialog, find the action `move_forward`, and press the button.
5. In the **Event Configuration** pop-up dialog, press the `W` key followed by clicking the `OK` button.
6. A child row will be added to the action that reads `W (Physical)`.
7. Press the `Close` button to close the **Input Map** dialog.
diff --git a/docs/nodes/properties.md b/docs/nodes/properties.md
index 25b6c6a..b8fe69d 100644
--- a/docs/nodes/properties.md
+++ b/docs/nodes/properties.md
@@ -17,7 +17,7 @@ You can create a **Set** or **Get** node for a property by:
1. Right-clicking in the graph or dragging a connection from an existing node
2. In the **All Actions** dialog, search for the property of interest, i.e. `Get Position`.
-3. Make sure that the selection has an icon similar to `.P` and not `.f()` on the right.
+3. Make sure that the selection has an icon similar to and not on the right.
4. Either press the **Add** button or simply hit **Enter**.
Using **Property** nodes allows an `Orchestration` to read or modify the state of that property.
diff --git a/docs/nodes/signals.md b/docs/nodes/signals.md
index b4d5ee2..da4ae0d 100644
--- a/docs/nodes/signals.md
+++ b/docs/nodes/signals.md
@@ -12,7 +12,7 @@ In addition, signals can provide contextual information using function arguments
To create a new signal in an orchestration, follow these steps:
-1. Press the `+` button on the **Signal** component view.
+1. Press the button on the **Signal** component view.
2. Enter a unique name when the new signal entry is added.
This is the name of the signal that parts of the orchestration as well as external Godot objects can connect and be notified when the signal is fired.
diff --git a/docs/nodes/variables.md b/docs/nodes/variables.md
index c69712b..44d53ef 100644
--- a/docs/nodes/variables.md
+++ b/docs/nodes/variables.md
@@ -13,44 +13,44 @@ Variables can be created using a variety of different types, including data type
Arrays, Dictionaries, and specialized Packed-Arrays can be created too.
Each type is specifically color coded for easy identification:
-| Variable Type | Color | Represents |
-|:-------------------|:---------------------------------------------------:|:---------------------------------------------------------------|
-| Boolean | | True or false value (`bool`). |
-| Integer | | Signed 64-bit value between `-2^63` and `2^63-1`. |
-| Float | | Signed 64-bit double-precision floating-point number. |
-| String | | Group of alphanumeric characters, such as `Hello World`. |
-| StringName | | An immutable string that is faster to compare than `String`. |
-| Rect2 | | 2D axis-aligned bounding box using floating-point coordinates. |
-| Rect2i | | 2D axis-aligned bounding box using integer coordinates. |
-| Vector2 | | 2D vector using floating-point coordinates. |
-| Vector2i | | 2D vector using integer coordinates. |
-| Vector3 | | 3D vector using floating-point coordinates. |
-| Vector3i | | 3D vector using integer coordinates. |
-| Vector4 | | 4D vector using floating-point coordinates. |
-| Vector4i | | 4D vector using integer coordinates. |
-| Transform2D | | 2x3 matrix representing a 2D transformation. |
-| Transform3D | | 3x4 matrix representing a 3D transformation. |
-| Plane | | A plane in Hessian normal form. |
-| Quaternion | | Represents 3D rotations. |
-| AABB | | 3D axis-aligned bounding box. |
-| Basis | | 3x3 matrix for representing 3D rotation and scale. |
-| Projection | | 4x4 matrix for 3D projective transformations. |
-| Color | | RGBA color. |
-| NodePath | | Pre-parsed scene tree path, can be relative or absolute. |
-| RID | | Handle for a `Resource`'s unique identifier. |
-| Object | | Base class for all classes in the Godot engine. |
-| Dictionary | | Container that holds key-value pairs. |
-| Array | | Container that holds a sequence of elements. |
-| Callable | | Represents a method or a standalone function callback. |
-| PackedByteArray | | Packed array of byte values. |
-| PackedStringArray | | Packed array of `String` values. |
-| PackedInt32Array | | Packed array of 32-bit integer values. |
-| PackedInt64Array | | Packed array of 64-bit integer values. |
-| PackedFloat32Array | | Packed array of 32-bit floating-point values. |
-| PackedFloat64Array | | Packed array of 64-bit floating-point values. |
-| PackedVector2Array | | Packed array of `Vector2` values. |
-| PackedVector3Array | | Packed array of `Vector3` values. |
-| PackedColorArray | | Packed array of `Color` values. |
+| Variable Type | Color | Icon | Represents |
+|:-------------------|:---------------------------------------------------:|:---------------------------------------:|:---------------------------------------------------------------|
+| Boolean | | | True or false value (`bool`). |
+| Integer | | | Signed 64-bit value between `-2^63` and `2^63-1`. |
+| Float | | | Signed 64-bit double-precision floating-point number. |
+| String | | | Group of alphanumeric characters, such as `Hello World`. |
+| StringName | | | An immutable string that is faster to compare than `String`. |
+| Rect2 | | | 2D axis-aligned bounding box using floating-point coordinates. |
+| Rect2i | | | 2D axis-aligned bounding box using integer coordinates. |
+| Vector2 | | | 2D vector using floating-point coordinates. |
+| Vector2i | | | 2D vector using integer coordinates. |
+| Vector3 | | | 3D vector using floating-point coordinates. |
+| Vector3i | | | 3D vector using integer coordinates. |
+| Vector4 | | | 4D vector using floating-point coordinates. |
+| Vector4i | | | 4D vector using integer coordinates. |
+| Transform2D | | | 2x3 matrix representing a 2D transformation. |
+| Transform3D | | | 3x4 matrix representing a 3D transformation. |
+| Plane | | | A plane in Hessian normal form. |
+| Quaternion | | | Represents 3D rotations. |
+| AABB | | | 3D axis-aligned bounding box. |
+| Basis | | | 3x3 matrix for representing 3D rotation and scale. |
+| Projection | | | 4x4 matrix for 3D projective transformations. |
+| Color | | | RGBA color. |
+| NodePath | | | Pre-parsed scene tree path, can be relative or absolute. |
+| RID | | | Handle for a `Resource`'s unique identifier. |
+| Object | | | Base class for all classes in the Godot engine. |
+| Dictionary | | | Container that holds key-value pairs. |
+| Array | | | Container that holds a sequence of elements. |
+| Callable | | | Represents a method or a standalone function callback. |
+| PackedByteArray | | | Packed array of byte values. |
+| PackedStringArray | | | Packed array of `String` values. |
+| PackedInt32Array | | | Packed array of 32-bit integer values. |
+| PackedInt64Array | | | Packed array of 64-bit integer values. |
+| PackedFloat32Array | | | Packed array of 32-bit floating-point values. |
+| PackedFloat64Array | | | Packed array of 64-bit floating-point values. |
+| PackedVector2Array | | | Packed array of `Vector2` values. |
+| PackedVector3Array | | | Packed array of `Vector3` values. |
+| PackedColorArray | | | Packed array of `Color` values. |
:::info
We are aware that variables cannot be assigned to all Godot engine values, such as enumerations.
@@ -68,8 +68,8 @@ For a variable to be modified from outside the orchestration, it must be **expor
-Variables in the component panel are private by default, showing a closed eye icon.
-By clicking the eye icon or selecting the variable and toggling the **Exported** property in the **Inspector** view, the variable can be made accessible from outside the orchestration.
+Variables in the component panel are private by default, using the .
+By clicking the eye icon or selecting the variable and toggling the **Exported** property in the **Inspector** view, the variable can be made accessible from outside the orchestration, using the icon .
Once a variable has been exported, if the orchestration is attached to any scene nodes, the value of the variable can be initialized for each specific scene node that the orchestration is attached separately.
@@ -81,7 +81,7 @@ This allows for creating orchestrations with unique behaviors and reusing that b
By default, a variable is private, or *not exported*.
Private variables are those that can be modified from within the owning orchestration graphs; however, are not accessible from external actors such as `C#`, `GDScript`, or other orchestrations.
-You can determine whether a variable is private based on the closed or open eye icon to the right of the variable name in the component panel.
+You can determine whether a variable is private if it has the icon next to its name in the **Component** view.
diff --git a/src/components/EditorIcon/index.js b/src/components/EditorIcon/index.js
new file mode 100644
index 0000000..9011256
--- /dev/null
+++ b/src/components/EditorIcon/index.js
@@ -0,0 +1,7 @@
+import React from 'react';
+import styles from './styles.module.css';
+
+export default function EditorIcon({children, name}) {
+ const baseUrl = "https://raw.githubusercontent.com/godotengine/godot/master/editor/icons/";
+ return (
);
+}
\ No newline at end of file
diff --git a/src/components/EditorIcon/styles.module.css b/src/components/EditorIcon/styles.module.css
new file mode 100644
index 0000000..fd6c217
--- /dev/null
+++ b/src/components/EditorIcon/styles.module.css
@@ -0,0 +1,9 @@
+.editorIconContainer {
+ display: inline-block;
+ width: 24px;
+ text-align: center;
+}
+
+.editorIcon {
+
+}
\ No newline at end of file
diff --git a/src/theme/MDXComponents/index.js b/src/theme/MDXComponents/index.js
index c17581c..77c5b92 100644
--- a/src/theme/MDXComponents/index.js
+++ b/src/theme/MDXComponents/index.js
@@ -3,6 +3,7 @@ import OriginalMDXComponents from '@docusaurus/theme-classic/lib/theme/MDXCompon
import ConnectionColor from '@site/src/components/ConnectionColor';
import Figure from '@site/src/components/Figure';
import Figures from '@site/src/components/Figures';
+import EditorIcon from '@site/src/components/EditorIcon';
import ExternalLink from '@site/src/components/ExternalLink';
export default function MDXComponents(components) {
@@ -12,6 +13,7 @@ export default function MDXComponents(components) {
ConnectionColor,
Figure,
Figures,
+ EditorIcon,
ExternalLink,
};
};
\ No newline at end of file
