botaccount
/
limboai
mirror of https://github.com/limbonaut/limboai.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Port BBParam editor to GDExtension (#287)

This commit is contained in:
Serhii Snitsaruk 2025-02-18 12:39:47 +01:00 committed by GitHub
parent 8e3f37d46a
commit 1a192b6129
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 160 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
compat/forward_decl.h Normal file
View File

@ -0,0 +1,28 @@
/**
* forward_decl.h
* =============================================================================
* Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
*
* Use of this source code is governed by an MIT-style
* license that can be found in the LICENSE file or at
* https://opensource.org/licenses/MIT.
* =============================================================================
*/
#ifndef FORWARD_DECL_H
#define FORWARD_DECL_H
// * It's necessary to enclose Godot forward declarations within the `godot`
// * namespace in GDExtension.
#ifdef LIMBOAI_MODULE
#define GODOT_FORWARD_DECLARATIONS()
#define ENDOF_FORWARD_DECLARATIONS()
#endif // ! LIMBOAI_MODULE
#ifdef LIMBOAI_GDEXTENSION
#define GODOT_FORWARD_DECLARATIONS() namespace godot {
#define ENDOF_FORWARD_DECLARATIONS() } //namespace godot
#endif // ! LIMBOAI_GDEXTENSION
#endif // ! FORWARD_DECL_H

260
editor/editor_property_bb_param.cpp
View File

@ -11,37 +11,32 @@
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
#ifdef LIMBOAI_MODULE
#include "editor_property_bb_param.h" #include "editor_property_bb_param.h"
#include "../blackboard/bb_param/bb_param.h"
#include "../blackboard/bb_param/bb_variant.h" #include "../blackboard/bb_param/bb_variant.h"
#include "../util/limbo_string_names.h" #include "../util/limbo_string_names.h"
#include "editor_property_variable_name.h" #include "editor_property_variable_name.h"
#include "mode_switch_button.h"
#include "core/error/error_macros.h" #ifdef LIMBOAI_MODULE
#include "core/io/marshalls.h" #include "editor/editor_interface.h"
#include "core/object/class_db.h" #include "scene/gui/margin_container.h"
#include "core/object/object.h"
#include "core/object/ref_counted.h"
#include "core/os/memory.h"
#include "core/string/print_string.h"
#include "core/variant/variant.h"
#include "editor/editor_inspector.h"
#include "editor/editor_properties.h"
#include "editor/editor_properties_array_dict.h"
#include "editor/editor_properties_vector.h"
#include "editor/editor_settings.h"
#include "scene/gui/base_button.h"
#include "scene/gui/box_container.h"
#include "scene/gui/button.h"
#include "scene/gui/line_edit.h"
#include "scene/gui/menu_button.h" #include "scene/gui/menu_button.h"
#endif // LIMBOAI_MODULE
#ifdef LIMBOAI_GDEXTENSION
#include <godot_cpp/classes/editor_inspector.hpp>
#include <godot_cpp/classes/editor_interface.hpp>
#include <godot_cpp/classes/h_box_container.hpp>
#include <godot_cpp/classes/margin_container.hpp>
#include <godot_cpp/classes/menu_button.hpp>
#include <godot_cpp/classes/popup_menu.hpp>
#endif // LIMBOAI_GDEXTENSION
Ref<BBParam> EditorPropertyBBParam::_get_edited_param() { Ref<BBParam> EditorPropertyBBParam::_get_edited_param() {
Ref<BBParam> param = get_edited_property_value(); Ref<BBParam> param;
if (get_edited_object()) {
param = get_edited_object()->get(get_edited_property());
}
if (param.is_null()) { if (param.is_null()) {
// Create parameter resource if null. // Create parameter resource if null.
param = ClassDB::instantiate(param_type); param = ClassDB::instantiate(param_type);
@ -50,159 +45,50 @@ Ref<BBParam> EditorPropertyBBParam::_get_edited_param() {
return param; return param;
} }
void EditorPropertyBBParam::_create_value_editor(Variant::Type p_type) { void EditorPropertyBBParam::_create_value_editor(Object *p_object, const String &p_property, Variant::Type p_type) {
if (value_editor) { if (value_editor) {
if (value_editor->get_meta(SNAME("_param_type")) == Variant(p_type)) { if (value_editor->get_meta(LW_NAME(_param_type)) == Variant(p_type)) {
return; return;
} }
_remove_value_editor(); _remove_value_editor();
} }
const String hint_text = p_type == Variant::OBJECT ? "Resource" : "";
value_editor = EditorInterface::get_singleton()->get_inspector()->instantiate_property_editor(p_object, p_type, p_property, property_hint, hint_text, PROPERTY_USAGE_EDITOR);
bool is_bottom = false; bool is_bottom = false;
switch (p_type) { switch (p_type) {
case Variant::NIL: { case Variant::STRING:
value_editor = memnew(EditorPropertyNil);
} break;
case Variant::BOOL: {
value_editor = memnew(EditorPropertyCheck);
} break;
case Variant::INT: {
EditorPropertyInteger *editor = memnew(EditorPropertyInteger);
editor->setup(-100000, 100000, 1, false, true, true);
value_editor = editor;
} break;
case Variant::FLOAT: {
EditorPropertyFloat *editor = memnew(EditorPropertyFloat);
editor->setup(-100000, 100000, EDITOR_GET("interface/inspector/default_float_step"), true, false, true, true);
value_editor = editor;
} break;
case Variant::STRING: {
if (property_hint == PROPERTY_HINT_MULTILINE_TEXT) {
value_editor = memnew(EditorPropertyMultilineText);
} else {
value_editor = memnew(EditorPropertyText);
}
is_bottom = (property_hint == PROPERTY_HINT_MULTILINE_TEXT);
} break;
case Variant::VECTOR2: {
EditorPropertyVector2 *editor = memnew(EditorPropertyVector2);
editor->setup(-100000, 100000, EDITOR_GET("interface/inspector/default_float_step"), true);
value_editor = editor;
} break;
case Variant::VECTOR2I: {
EditorPropertyVector2i *editor = memnew(EditorPropertyVector2i);
editor->setup(-100000, 100000);
value_editor = editor;
} break;
case Variant::RECT2: {
EditorPropertyRect2 *editor = memnew(EditorPropertyRect2);
editor->setup(-100000, 100000, EDITOR_GET("interface/inspector/default_float_step"), true);
value_editor = editor;
is_bottom = true;
} break;
case Variant::RECT2I: {
EditorPropertyRect2i *editor = memnew(EditorPropertyRect2i);
editor->setup(-100000, 100000);
value_editor = editor;
is_bottom = true;
} break;
case Variant::VECTOR3: {
EditorPropertyVector3 *editor = memnew(EditorPropertyVector3);
editor->setup(-100000, 100000, EDITOR_GET("interface/inspector/default_float_step"), true);
value_editor = editor;
is_bottom = true;
} break;
case Variant::VECTOR3I: {
EditorPropertyVector3i *editor = memnew(EditorPropertyVector3i);
editor->setup(-100000, 100000);
value_editor = editor;
is_bottom = true;
} break;
case Variant::VECTOR4: {
EditorPropertyVector4 *editor = memnew(EditorPropertyVector4);
editor->setup(-100000, 100000, EDITOR_GET("interface/inspector/default_float_step"), true);
value_editor = editor;
is_bottom = true;
} break;
case Variant::VECTOR4I: {
EditorPropertyVector4i *editor = memnew(EditorPropertyVector4i);
editor->setup(-100000, 100000);
value_editor = editor;
is_bottom = true;
} break;
case Variant::TRANSFORM2D: {
EditorPropertyTransform2D *editor = memnew(EditorPropertyTransform2D);
editor->setup(-100000, 100000, EDITOR_GET("interface/inspector/default_float_step"), true);
value_editor = editor;
is_bottom = true;
} break;
case Variant::PLANE: {
EditorPropertyPlane *editor = memnew(EditorPropertyPlane);
editor->setup(-100000, 100000, EDITOR_GET("interface/inspector/default_float_step"), true);
value_editor = editor;
is_bottom = true;
} break;
case Variant::QUATERNION: {
EditorPropertyQuaternion *editor = memnew(EditorPropertyQuaternion);
editor->setup(-100000, 100000, EDITOR_GET("interface/inspector/default_float_step"), true);
value_editor = editor;
is_bottom = true;
} break;
case Variant::AABB: {
EditorPropertyAABB *editor = memnew(EditorPropertyAABB);
editor->setup(-100000, 100000, EDITOR_GET("interface/inspector/default_float_step"), true);
value_editor = editor;
is_bottom = true;
} break;
case Variant::BASIS: {
EditorPropertyBasis *editor = memnew(EditorPropertyBasis);
editor->setup(-100000, 100000, EDITOR_GET("interface/inspector/default_float_step"), true);
value_editor = editor;
is_bottom = true;
} break;
case Variant::TRANSFORM3D: {
EditorPropertyTransform3D *editor = memnew(EditorPropertyTransform3D);
editor->setup(-100000, 100000, EDITOR_GET("interface/inspector/default_float_step"), true);
value_editor = editor;
is_bottom = true;
} break;
case Variant::PROJECTION: {
EditorPropertyProjection *editor = memnew(EditorPropertyProjection);
editor->setup(-100000, 100000, EDITOR_GET("interface/inspector/default_float_step"), true);
value_editor = editor;
is_bottom = true;
} break;
case Variant::COLOR: {
value_editor = memnew(EditorPropertyColor);
} break;
case Variant::STRING_NAME: { case Variant::STRING_NAME: {
EditorPropertyText *editor = memnew(EditorPropertyText);
editor->set_string_name(true);
value_editor = editor;
is_bottom = (property_hint == PROPERTY_HINT_MULTILINE_TEXT); is_bottom = (property_hint == PROPERTY_HINT_MULTILINE_TEXT);
} break; } break;
case Variant::NODE_PATH: {
value_editor = memnew(EditorPropertyNodePath);
} break;
// case Variant::RID: {
// } break;
// case Variant::SIGNAL: {
// } break;
// case Variant::CALLABLE: {
// } break;
case Variant::OBJECT: {
// Only resources are supported.
EditorPropertyResource *editor = memnew(EditorPropertyResource);
editor->setup(_get_edited_param().ptr(), SNAME("saved_value"), "Resource");
value_editor = editor;
is_bottom = true;
} break;
case Variant::DICTIONARY: {
value_editor = memnew(EditorPropertyDictionary);
is_bottom = true;
} break;
case Variant::NIL:
case Variant::BOOL:
case Variant::INT:
case Variant::FLOAT:
case Variant::VECTOR2:
case Variant::VECTOR2I:
case Variant::COLOR:
case Variant::NODE_PATH: {
is_bottom = false;
} break;
case Variant::RECT2:
case Variant::RECT2I:
case Variant::VECTOR3:
case Variant::VECTOR3I:
case Variant::VECTOR4:
case Variant::VECTOR4I:
case Variant::TRANSFORM2D:
case Variant::PLANE:
case Variant::QUATERNION:
case Variant::AABB:
case Variant::BASIS:
case Variant::TRANSFORM3D:
case Variant::PROJECTION:
case Variant::OBJECT:
case Variant::DICTIONARY:
case Variant::ARRAY: case Variant::ARRAY:
case Variant::PACKED_BYTE_ARRAY: case Variant::PACKED_BYTE_ARRAY:
case Variant::PACKED_INT32_ARRAY: case Variant::PACKED_INT32_ARRAY:
@ -213,23 +99,20 @@ void EditorPropertyBBParam::_create_value_editor(Variant::Type p_type) {
case Variant::PACKED_VECTOR2_ARRAY: case Variant::PACKED_VECTOR2_ARRAY:
case Variant::PACKED_VECTOR3_ARRAY: case Variant::PACKED_VECTOR3_ARRAY:
case Variant::PACKED_COLOR_ARRAY: { case Variant::PACKED_COLOR_ARRAY: {
EditorPropertyArray *editor = memnew(EditorPropertyArray);
editor->setup(p_type);
value_editor = editor;
is_bottom = true; is_bottom = true;
} break; } break;
default: { default: {
ERR_PRINT("Unexpected variant type!"); ERR_PRINT("Unexpected variant type!");
value_editor = memnew(EditorPropertyNil);
} }
} }
value_editor->set_name_split_ratio(0.0); value_editor->set_name_split_ratio(0.0);
value_editor->set_use_folding(is_using_folding()); value_editor->set_use_folding(is_using_folding());
value_editor->set_selectable(false); value_editor->set_selectable(false);
value_editor->set_h_size_flags(SIZE_EXPAND_FILL); value_editor->set_h_size_flags(SIZE_EXPAND_FILL);
value_editor->set_meta(SNAME("_param_type"), p_type); value_editor->set_meta(LW_NAME(_param_type), p_type);
value_editor->connect(SNAME("property_changed"), callable_mp(this, &EditorPropertyBBParam::_value_edited)); value_editor->connect(LW_NAME(property_changed), callable_mp(this, &EditorPropertyBBParam::_value_edited));
if (is_bottom) { if (is_bottom) {
bottom_container->add_child(value_editor); bottom_container->add_child(value_editor);
set_bottom_editor(bottom_container); set_bottom_editor(bottom_container);
@ -272,7 +155,11 @@ void EditorPropertyBBParam::_variable_edited(const String &p_property, Variant p
_get_edited_param()->set_variable(p_value); _get_edited_param()->set_variable(p_value);
} }
#ifdef LIMBOAI_MODULE
void EditorPropertyBBParam::update_property() { void EditorPropertyBBParam::update_property() {
#elif LIMBOAI_GDEXTENSION
void EditorPropertyBBParam::_update_property() {
#endif
if (!initialized) { if (!initialized) {
// Initialize UI -- needed after https://github.com/godotengine/godot/commit/db7175458a0532f1efe733f303ad2b55a02a52a5 // Initialize UI -- needed after https://github.com/godotengine/godot/commit/db7175458a0532f1efe733f303ad2b55a02a52a5
_notification(NOTIFICATION_THEME_CHANGED); _notification(NOTIFICATION_THEME_CHANGED);
@ -282,19 +169,20 @@ void EditorPropertyBBParam::update_property() {
if (param->get_value_source() == BBParam::BLACKBOARD_VAR) { if (param->get_value_source() == BBParam::BLACKBOARD_VAR) {
_remove_value_editor(); _remove_value_editor();
variable_editor->set_object_and_property(param.ptr(), SNAME("variable")); variable_editor->set_object_and_property(param.ptr(), LW_NAME(variable));
variable_editor->setup(plan, false, param->get_variable_expected_type()); variable_editor->setup(plan, false, param->get_variable_expected_type());
variable_editor->update_property(); variable_editor->update_property();
variable_editor->show(); variable_editor->show();
bottom_container->hide(); bottom_container->hide();
type_choice->set_button_icon(get_editor_theme_icon(SNAME("LimboExtraVariable"))); type_choice->set_button_icon(LimboUtility::get_singleton()->get_task_icon(LW_NAME(LimboExtraVariable)));
} else { } else {
_create_value_editor(param->get_type()); // _create_value_editor(param->get_type());
_create_value_editor(param.ptr(), LW_NAME(saved_value), param->get_type());
variable_editor->hide(); variable_editor->hide();
value_editor->show(); value_editor->show();
value_editor->set_object_and_property(param.ptr(), SNAME("saved_value")); value_editor->set_object_and_property(param.ptr(), LW_NAME(saved_value));
value_editor->update_property(); value_editor->update_property();
type_choice->set_button_icon(get_editor_theme_icon(Variant::get_type_name(param->get_type()))); type_choice->set_button_icon(get_theme_icon(Variant::get_type_name(param->get_type()), LW_NAME(EditorIcons)));
} }
} }
@ -316,27 +204,27 @@ void EditorPropertyBBParam::_notification(int p_what) {
{ {
String type = Variant::get_type_name(_get_edited_param()->get_type()); String type = Variant::get_type_name(_get_edited_param()->get_type());
type_choice->set_button_icon(get_editor_theme_icon(type)); type_choice->set_button_icon(get_theme_icon(type, LW_NAME(EditorIcons)));
} }
// Initialize type choice. // Initialize type choice.
PopupMenu *type_menu = type_choice->get_popup(); PopupMenu *type_menu = type_choice->get_popup();
type_menu->clear(); type_menu->clear();
type_menu->add_icon_item(get_editor_theme_icon(SNAME("LimboExtraVariable")), TTR("Blackboard Variable"), ID_BIND_VAR); type_menu->add_icon_item(LimboUtility::get_singleton()->get_task_icon(LW_NAME(LimboExtraVariable)), TTR("Blackboard Variable"), ID_BIND_VAR);
type_menu->add_separator(); type_menu->add_separator();
Ref<BBParam> param = _get_edited_param(); Ref<BBParam> param = _get_edited_param();
bool is_variant_param = param->is_class_ptr(BBVariant::get_class_ptr_static()); bool is_variant_param = IS_CLASS(param, BBVariant);
if (is_variant_param) { if (is_variant_param) {
for (int i = 0; i < Variant::VARIANT_MAX; i++) { for (int i = 0; i < Variant::VARIANT_MAX; i++) {
if (i == Variant::RID || i == Variant::CALLABLE || i == Variant::SIGNAL) { if (i == Variant::RID || i == Variant::CALLABLE || i == Variant::SIGNAL) {
continue; continue;
} }
String type = Variant::get_type_name(Variant::Type(i)); String type = Variant::get_type_name(Variant::Type(i));
type_menu->add_icon_item(get_editor_theme_icon(type), type, i); type_menu->add_icon_item(get_theme_icon(type, LW_NAME(EditorIcons)), type, i);
} }
} else { // Not a variant param. } else { // Not a variant param.
String type = Variant::get_type_name(param->get_type()); String type = Variant::get_type_name(param->get_type());
type_menu->add_icon_item(get_editor_theme_icon(type), type, param->get_type()); type_menu->add_icon_item(get_theme_icon(type, LW_NAME(EditorIcons)), type, param->get_type());
} }
initialized = true; initialized = true;
@ -367,18 +255,26 @@ EditorPropertyBBParam::EditorPropertyBBParam() {
variable_editor = memnew(EditorPropertyVariableName); variable_editor = memnew(EditorPropertyVariableName);
editor_hbox->add_child(variable_editor); editor_hbox->add_child(variable_editor);
variable_editor->set_h_size_flags(SIZE_EXPAND_FILL); variable_editor->set_h_size_flags(SIZE_EXPAND_FILL);
variable_editor->connect(SNAME("property_changed"), callable_mp(this, &EditorPropertyBBParam::_variable_edited)); variable_editor->connect(LW_NAME(property_changed), callable_mp(this, &EditorPropertyBBParam::_variable_edited));
param_type = SNAME("BBString"); param_type = LW_NAME(BBString);
} }
//***** EditorInspectorPluginBBParam //***** EditorInspectorPluginBBParam
#ifdef LIMBOAI_MODULE
bool EditorInspectorPluginBBParam::can_handle(Object *p_object) { bool EditorInspectorPluginBBParam::can_handle(Object *p_object) {
#elif LIMBOAI_GDEXTENSION
bool EditorInspectorPluginBBParam::_can_handle(Object *p_object) const {
#endif
return true; // Handles everything. return true; // Handles everything.
} }
#ifdef LIMBOAI_MODULE
bool EditorInspectorPluginBBParam::parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField<PropertyUsageFlags> p_usage, const bool p_wide) { bool EditorInspectorPluginBBParam::parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField<PropertyUsageFlags> p_usage, const bool p_wide) {
#elif LIMBOAI_GDEXTENSION
bool EditorInspectorPluginBBParam::_parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField<PropertyUsageFlags> p_usage, const bool p_wide) {
#endif
if (p_hint == PROPERTY_HINT_RESOURCE_TYPE && p_hint_text.begins_with("BB")) { if (p_hint == PROPERTY_HINT_RESOURCE_TYPE && p_hint_text.begins_with("BB")) {
// TODO: Add more rigid hint check. // TODO: Add more rigid hint check.
EditorPropertyBBParam *editor = memnew(EditorPropertyBBParam()); EditorPropertyBBParam *editor = memnew(EditorPropertyBBParam());
@ -389,6 +285,4 @@ bool EditorInspectorPluginBBParam::parse_property(Object *p_object, const Varian
return false; return false;
} }
#endif // ! LIMBOAI_MODULE
#endif // ! TOOLS_ENABLED #endif // ! TOOLS_ENABLED

41
editor/editor_property_bb_param.h
View File

@ -14,19 +14,26 @@
#ifndef EDITOR_PROPERTY_BB_PARAM_H #ifndef EDITOR_PROPERTY_BB_PARAM_H
#define EDITOR_PROPERTY_BB_PARAM_H #define EDITOR_PROPERTY_BB_PARAM_H
#include "../compat/forward_decl.h"
#ifdef LIMBOAI_MODULE #ifdef LIMBOAI_MODULE
#include "editor/editor_inspector.h" #include "editor/editor_inspector.h"
#endif // ! LIMBOAI_MODULE
#include "../blackboard/bb_param/bb_param.h" #ifdef LIMBOAI_GDEXTENSION
#include "../blackboard/blackboard_plan.h" #include <godot_cpp/classes/editor_inspector_plugin.hpp>
#include "mode_switch_button.h" #include <godot_cpp/classes/editor_property.hpp>
using namespace godot;
#include "scene/gui/box_container.h" #endif // ! LIMBOAI_GDEXTENSION
#include "scene/gui/margin_container.h"
#include "scene/gui/menu_button.h"
class EditorPropertyVariableName; class EditorPropertyVariableName;
class BBParam;
class BlackboardPlan;
GODOT_FORWARD_DECLARATIONS()
class MarginContainer;
class MenuButton;
class HBoxContainer;
ENDOF_FORWARD_DECLARATIONS()
class EditorPropertyBBParam : public EditorProperty { class EditorPropertyBBParam : public EditorProperty {
GDCLASS(EditorPropertyBBParam, EditorProperty); GDCLASS(EditorPropertyBBParam, EditorProperty);
@ -49,7 +56,7 @@ private:
Ref<BBParam> _get_edited_param(); Ref<BBParam> _get_edited_param();
void _create_value_editor(Variant::Type p_type); void _create_value_editor(Object *p_object, const String &p_property, Variant::Type p_type);
void _remove_value_editor(); void _remove_value_editor();
void _value_edited(const String &p_property, Variant p_value, const String &p_name = "", bool p_changing = false); void _value_edited(const String &p_property, Variant p_value, const String &p_name = "", bool p_changing = false);
@ -57,10 +64,16 @@ private:
void _type_selected(int p_index); void _type_selected(int p_index);
protected: protected:
static void _bind_methods() {}
void _notification(int p_what); void _notification(int p_what);
public: public:
#ifdef LIMBOAI_MODULE
virtual void update_property() override; virtual void update_property() override;
#elif LIMBOAI_GDEXTENSION
virtual void _update_property() override;
#endif
void setup(PropertyHint p_hint, const String &p_hint_text, const Ref<BlackboardPlan> &p_plan); void setup(PropertyHint p_hint, const String &p_hint_text, const Ref<BlackboardPlan> &p_plan);
EditorPropertyBBParam(); EditorPropertyBBParam();
@ -72,15 +85,21 @@ class EditorInspectorPluginBBParam : public EditorInspectorPlugin {
private: private:
Callable plan_getter; Callable plan_getter;
protected:
static void _bind_methods() {}
public: public:
#ifdef LIMBOAI_MODULE
virtual bool can_handle(Object *p_object) override; virtual bool can_handle(Object *p_object) override;
virtual bool parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField<PropertyUsageFlags> p_usage, const bool p_wide = false) override; virtual bool parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField<PropertyUsageFlags> p_usage, const bool p_wide = false) override;
#elif LIMBOAI_GDEXTENSION
virtual bool _can_handle(Object *p_object) const override;
virtual bool _parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField<PropertyUsageFlags> p_usage, const bool p_wide = false) override;
#endif
void set_plan_getter(const Callable &p_getter) { plan_getter = p_getter; } void set_plan_getter(const Callable &p_getter) { plan_getter = p_getter; }
}; };
#endif // ! LIMBOAI_MODULE
#endif // ! EDITOR_PROPERTY_BB_PARAM_H #endif // ! EDITOR_PROPERTY_BB_PARAM_H
#endif // ! TOOLS_ENABLED #endif // ! TOOLS_ENABLED

4
editor/limbo_ai_editor_plugin.cpp
View File

@ -1938,12 +1938,10 @@ void LimboAIEditorPlugin::_notification(int p_notification) {
EditorInspectorPluginPropertyPath *path_plugin = memnew(EditorInspectorPluginPropertyPath); EditorInspectorPluginPropertyPath *path_plugin = memnew(EditorInspectorPluginPropertyPath);
add_inspector_plugin(path_plugin); add_inspector_plugin(path_plugin);
#ifdef LIMBOAI_MODULE
// ! Only used in the module version.
EditorInspectorPluginBBParam *param_plugin = memnew(EditorInspectorPluginBBParam); EditorInspectorPluginBBParam *param_plugin = memnew(EditorInspectorPluginBBParam);
param_plugin->set_plan_getter(Callable(limbo_ai_editor, "get_edited_blackboard_plan")); param_plugin->set_plan_getter(Callable(limbo_ai_editor, "get_edited_blackboard_plan"));
add_inspector_plugin(param_plugin); add_inspector_plugin(param_plugin);
#endif // LIMBOAI_MODULE
} break; } break;
case NOTIFICATION_ENTER_TREE: { case NOTIFICATION_ENTER_TREE: {
// Add BehaviorTree to the list of resources that should open in a new inspector. // Add BehaviorTree to the list of resources that should open in a new inspector.

3
register_types.cpp
View File

@ -100,6 +100,7 @@
#include "editor/debugger/behavior_tree_data.h" #include "editor/debugger/behavior_tree_data.h"
#include "editor/debugger/limbo_debugger.h" #include "editor/debugger/limbo_debugger.h"
#include "editor/debugger/limbo_debugger_plugin.h" #include "editor/debugger/limbo_debugger_plugin.h"
#include "editor/editor_property_bb_param.h"
#include "editor/mode_switch_button.h" #include "editor/mode_switch_button.h"
#include "editor/tree_search.h" #include "editor/tree_search.h"
#include "hsm/limbo_hsm.h" #include "hsm/limbo_hsm.h"
@ -268,6 +269,8 @@ void initialize_limboai_module(ModuleInitializationLevel p_level) {
GDREGISTER_INTERNAL_CLASS(EditorPropertyPropertyPath); GDREGISTER_INTERNAL_CLASS(EditorPropertyPropertyPath);
GDREGISTER_INTERNAL_CLASS(EditorPropertyVariableName); GDREGISTER_INTERNAL_CLASS(EditorPropertyVariableName);
GDREGISTER_INTERNAL_CLASS(EditorInspectorPluginVariableName); GDREGISTER_INTERNAL_CLASS(EditorInspectorPluginVariableName);
GDREGISTER_INTERNAL_CLASS(EditorPropertyBBParam);
GDREGISTER_INTERNAL_CLASS(EditorInspectorPluginBBParam);
GDREGISTER_INTERNAL_CLASS(OwnerPicker); GDREGISTER_INTERNAL_CLASS(OwnerPicker);
GDREGISTER_INTERNAL_CLASS(LimboAIEditor); GDREGISTER_INTERNAL_CLASS(LimboAIEditor);
GDREGISTER_INTERNAL_CLASS(LimboAIEditorPlugin); GDREGISTER_INTERNAL_CLASS(LimboAIEditorPlugin);

14
util/limbo_string_names.cpp
View File

@ -28,6 +28,7 @@ LimboStringNames *LimboStringNames::singleton = nullptr;
LimboStringNames::LimboStringNames() { LimboStringNames::LimboStringNames() {
_generate_name = SN("_generate_name"); _generate_name = SN("_generate_name");
_param_type = SN("_param_type");
_replace_task = SN("_replace_task"); _replace_task = SN("_replace_task");
_update_task_tree = SN("_update_task_tree"); _update_task_tree = SN("_update_task_tree");
_weight_ = SN("_weight_"); _weight_ = SN("_weight_");
@ -41,12 +42,14 @@ LimboStringNames::LimboStringNames() {
add_child_at_index = SN("add_child_at_index"); add_child_at_index = SN("add_child_at_index");
AnimationFilter = SN("AnimationFilter"); AnimationFilter = SN("AnimationFilter");
BBParam = SN("BBParam"); BBParam = SN("BBParam");
BBString = SN("BBString");
behavior_tree_finished = SN("behavior_tree_finished"); behavior_tree_finished = SN("behavior_tree_finished");
bold = SN("bold"); bold = SN("bold");
button_down = SN("button_down"); button_down = SN("button_down");
button_up = SN("button_up"); button_up = SN("button_up");
call_deferred = SN("call_deferred"); call_deferred = SN("call_deferred");
changed = SN("changed"); changed = SN("changed");
class_icon_size = SN("class_icon_size");
Clear = SN("Clear"); Clear = SN("Clear");
Close = SN("Close"); Close = SN("Close");
dark_color_2 = SN("dark_color_2"); dark_color_2 = SN("dark_color_2");
@ -83,15 +86,15 @@ LimboStringNames::LimboStringNames() {
GuiTabMenuHl = SN("GuiTabMenuHl"); GuiTabMenuHl = SN("GuiTabMenuHl");
GuiTreeArrowDown = SN("GuiTreeArrowDown"); GuiTreeArrowDown = SN("GuiTreeArrowDown");
GuiTreeArrowRight = SN("GuiTreeArrowRight"); GuiTreeArrowRight = SN("GuiTreeArrowRight");
h_separation = SN("h_separation");
HeaderSmall = SN("HeaderSmall"); HeaderSmall = SN("HeaderSmall");
Help = SN("Help"); Help = SN("Help");
h_separation = SN("h_separation");
icon_max_width = SN("icon_max_width"); icon_max_width = SN("icon_max_width");
class_icon_size = SN("class_icon_size");
id_pressed = SN("id_pressed"); id_pressed = SN("id_pressed");
Info = SN("Info"); Info = SN("Info");
item_collapsed = SN("item_collapsed"); item_collapsed = SN("item_collapsed");
item_selected = SN("item_selected"); item_selected = SN("item_selected");
LimboExtraVariable = SN("LimboExtraVariable");
LimboVarAdd = SN("LimboVarAdd"); LimboVarAdd = SN("LimboVarAdd");
LimboVarEmpty = SN("LimboVarEmpty"); LimboVarEmpty = SN("LimboVarEmpty");
LimboVarError = SN("LimboVarError"); LimboVarError = SN("LimboVarError");
@ -116,6 +119,7 @@ LimboStringNames::LimboStringNames() {
popup_hide = SN("popup_hide"); popup_hide = SN("popup_hide");
pressed = SN("pressed"); pressed = SN("pressed");
probability_clicked = SN("probability_clicked"); probability_clicked = SN("probability_clicked");
property_changed = SN("property_changed");
Reload = SN("Reload"); Reload = SN("Reload");
Remove = SN("Remove"); Remove = SN("Remove");
remove_child = SN("remove_child"); remove_child = SN("remove_child");
@ -123,14 +127,15 @@ LimboStringNames::LimboStringNames() {
request_open_in_screen = SN("request_open_in_screen"); request_open_in_screen = SN("request_open_in_screen");
rmb_pressed = SN("rmb_pressed"); rmb_pressed = SN("rmb_pressed");
Save = SN("Save"); Save = SN("Save");
saved_value = SN("saved_value");
Script = SN("Script"); Script = SN("Script");
ScriptCreate = SN("ScriptCreate"); ScriptCreate = SN("ScriptCreate");
Search = SN("Search"); Search = SN("Search");
separation = SN("separation"); separation = SN("separation");
set_custom_name = SN("set_custom_name"); set_custom_name = SN("set_custom_name");
set_root_task = SN("set_root_task"); set_root_task = SN("set_root_task");
set_visible = SN("set_visible");
set_v_scroll = SN("set_v_scroll"); set_v_scroll = SN("set_v_scroll");
set_visible = SN("set_visible");
setup = SN("setup"); setup = SN("setup");
started = SN("started"); started = SN("started");
StatusWarning = SN("StatusWarning"); StatusWarning = SN("StatusWarning");
@ -138,9 +143,9 @@ LimboStringNames::LimboStringNames() {
task_activated = SN("task_activated"); task_activated = SN("task_activated");
task_button_pressed = SN("task_button_pressed"); task_button_pressed = SN("task_button_pressed");
task_button_rmb = SN("task_button_rmb"); task_button_rmb = SN("task_button_rmb");
tasks_dragged = SN("tasks_dragged");
task_meta = SN("task_meta"); task_meta = SN("task_meta");
task_selected = SN("task_selected"); task_selected = SN("task_selected");
tasks_dragged = SN("tasks_dragged");
text_changed = SN("text_changed"); text_changed = SN("text_changed");
text_submitted = SN("text_submitted"); text_submitted = SN("text_submitted");
timeout = SN("timeout"); timeout = SN("timeout");
@ -150,6 +155,7 @@ LimboStringNames::LimboStringNames() {
TripleBar = SN("TripleBar"); TripleBar = SN("TripleBar");
update_mode = SN("update_mode"); update_mode = SN("update_mode");
updated = SN("updated"); updated = SN("updated");
variable = SN("variable");
visibility_changed = SN("visibility_changed"); visibility_changed = SN("visibility_changed");
window_visibility_changed = SN("window_visibility_changed"); window_visibility_changed = SN("window_visibility_changed");

16
util/limbo_string_names.h
View File

@ -44,6 +44,7 @@ public:
_FORCE_INLINE_ static LimboStringNames *get_singleton() { return singleton; } _FORCE_INLINE_ static LimboStringNames *get_singleton() { return singleton; }
StringName _generate_name; StringName _generate_name;
StringName _param_type;
StringName _replace_task; StringName _replace_task;
StringName _update_task_tree; StringName _update_task_tree;
StringName _weight_; StringName _weight_;
@ -57,12 +58,14 @@ public:
StringName Add; StringName Add;
StringName AnimationFilter; StringName AnimationFilter;
StringName BBParam; StringName BBParam;
StringName BBString;
StringName behavior_tree_finished; StringName behavior_tree_finished;
StringName bold; StringName bold;
StringName button_down; StringName button_down;
StringName button_up; StringName button_up;
StringName call_deferred; StringName call_deferred;
StringName changed; StringName changed;
StringName class_icon_size;
StringName Clear; StringName Clear;
StringName Close; StringName Close;
StringName dark_color_2; StringName dark_color_2;
@ -88,8 +91,8 @@ public:
StringName favorite_tasks_changed; StringName favorite_tasks_changed;
StringName Favorites; StringName Favorites;
StringName FlatButton; StringName FlatButton;
StringName Focus;
StringName focus_exited; StringName focus_exited;
StringName Focus;
StringName font_color; StringName font_color;
StringName font_size; StringName font_size;
StringName font; StringName font;
@ -99,15 +102,15 @@ public:
StringName GuiTabMenuHl; StringName GuiTabMenuHl;
StringName GuiTreeArrowDown; StringName GuiTreeArrowDown;
StringName GuiTreeArrowRight; StringName GuiTreeArrowRight;
StringName h_separation;
StringName HeaderSmall; StringName HeaderSmall;
StringName Help; StringName Help;
StringName h_separation;
StringName icon_max_width; StringName icon_max_width;
StringName class_icon_size;
StringName id_pressed; StringName id_pressed;
StringName Info; StringName Info;
StringName item_collapsed; StringName item_collapsed;
StringName item_selected; StringName item_selected;
StringName LimboExtraVariable;
StringName LimboVarAdd; StringName LimboVarAdd;
StringName LimboVarEmpty; StringName LimboVarEmpty;
StringName LimboVarError; StringName LimboVarError;
@ -132,6 +135,7 @@ public:
StringName popup_hide; StringName popup_hide;
StringName pressed; StringName pressed;
StringName probability_clicked; StringName probability_clicked;
StringName property_changed;
StringName Reload; StringName Reload;
StringName remove_child; StringName remove_child;
StringName Remove; StringName Remove;
@ -139,14 +143,15 @@ public:
StringName request_open_in_screen; StringName request_open_in_screen;
StringName rmb_pressed; StringName rmb_pressed;
StringName Save; StringName Save;
StringName saved_value;
StringName Script; StringName Script;
StringName ScriptCreate; StringName ScriptCreate;
StringName Search; StringName Search;
StringName separation; StringName separation;
StringName set_custom_name; StringName set_custom_name;
StringName set_root_task; StringName set_root_task;
StringName set_visible;
StringName set_v_scroll; StringName set_v_scroll;
StringName set_visible;
StringName setup; StringName setup;
StringName started; StringName started;
StringName StatusWarning; StringName StatusWarning;
@ -154,9 +159,9 @@ public:
StringName task_activated; StringName task_activated;
StringName task_button_pressed; StringName task_button_pressed;
StringName task_button_rmb; StringName task_button_rmb;
StringName tasks_dragged;
StringName task_meta; StringName task_meta;
StringName task_selected; StringName task_selected;
StringName tasks_dragged;
StringName text_changed; StringName text_changed;
StringName text_submitted; StringName text_submitted;
StringName timeout; StringName timeout;
@ -166,6 +171,7 @@ public:
StringName TripleBar; StringName TripleBar;
StringName update_mode; StringName update_mode;
StringName updated; StringName updated;
StringName variable;
StringName visibility_changed; StringName visibility_changed;
StringName window_visibility_changed; StringName window_visibility_changed;