commit 53905b3cdf18656b1e75e5294eb6f65e15a930d9 Author: Relintai Date: Fri Apr 3 09:23:01 2020 +0200 Moved everything that is prop related from Voxelman to here. Note that Voxelman is required for this to compile for now. This will be fixed soon. diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7001be7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +.import +*.d +*.o +*.meta +*.obj +*.pyc +*.bc +*.os \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..e4b4927 --- /dev/null +++ b/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..b5bad00 --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# Props + +A prop module for godot. \ No newline at end of file diff --git a/SCsub b/SCsub new file mode 100644 index 0000000..8bd6dee --- /dev/null +++ b/SCsub @@ -0,0 +1,47 @@ +import os + +Import('env') + +module_env = env.Clone() + +if os.path.isdir('../mesh_data_resource'): + module_env.Append(CPPDEFINES=['MESH_DATA_RESOURCE_PRESENT']) + +sources = [ + + "register_types.cpp", + + "props/prop_data.cpp", + "props/prop_data_entry.cpp", + "props/prop_data_scene.cpp", + "props/prop_data_mesh.cpp", + "props/prop_data_light.cpp", + "props/prop_data_prop.cpp", + "props/prop_data_entity.cpp", + + "clutter/ground_clutter.cpp", + "clutter/ground_clutter_foliage.cpp", + + "prop_tool/prop_tool.cpp", + "prop_tool/prop_tool_entity.cpp", + "prop_tool/prop_tool_prop.cpp", + "prop_tool/prop_tool_scene.cpp", + "prop_tool/prop_tool_light.cpp", + "prop_tool/prop_tool_mesh.cpp", +] + +if env['tools']: + sources.append("prop_tool/prop_tool_editor_plugin.cpp") + +if ARGUMENTS.get('custom_modules_shared', 'no') == 'yes': + # Shared lib compilation + module_env.Append(CCFLAGS=['-fPIC']) + module_env['LIBS'] = [] + shared_lib = module_env.SharedLibrary(target='#bin/props', source=sources) + shared_lib_shim = shared_lib[0].name.rsplit('.', 1)[0] + env.Append(LIBS=[shared_lib_shim]) + env.Append(LIBPATH=['#bin']) +else: + # Static compilation + module_env.add_source_files(env.modules_sources, sources) + diff --git a/clutter/ground_clutter.cpp b/clutter/ground_clutter.cpp new file mode 100644 index 0000000..3bec974 --- /dev/null +++ b/clutter/ground_clutter.cpp @@ -0,0 +1,58 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "ground_clutter.h" + +#include "../../voxelman/world/voxel_chunk.h" + +bool GroundClutter::should_spawn(Ref chunk, int x, int y, int z) { + if (has_method("_should_spawn")) + return call("_should_spawn", chunk, x, y, z); + + return false; +} + +void GroundClutter::add_meshes_to(Ref mesher, Ref chunk, int x, int y, int z) { + if (has_method("_add_meshes_to")) + call("_add_meshes_to", mesher, chunk, x, y, z); +} + +void GroundClutter::add_textures_to(Ref packer) { + if (has_method("_add_textures_to")) + call("_add_textures_to", packer); +} + +GroundClutter::GroundClutter() { +} + +GroundClutter::~GroundClutter() { +} + +void GroundClutter::_bind_methods() { + BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::BOOL, "should"), "_should_spawn", PropertyInfo(Variant::OBJECT, "chunk", PROPERTY_HINT_RESOURCE_TYPE, "VoxelChunk"), PropertyInfo(Variant::INT, "x"), PropertyInfo(Variant::INT, "y"), PropertyInfo(Variant::INT, "z"))); + BIND_VMETHOD(MethodInfo("_add_meshes_to", PropertyInfo(Variant::OBJECT, "mesher", PROPERTY_HINT_RESOURCE_TYPE, "VoxelMesher"), PropertyInfo(Variant::OBJECT, "chunk", PROPERTY_HINT_RESOURCE_TYPE, "VoxelChunk"), PropertyInfo(Variant::INT, "x"), PropertyInfo(Variant::INT, "y"), PropertyInfo(Variant::INT, "z"))); + BIND_VMETHOD(MethodInfo("_add_textures_to", PropertyInfo(Variant::OBJECT, "packer", PROPERTY_HINT_RESOURCE_TYPE, "TexturePacker"))); + + ClassDB::bind_method(D_METHOD("should_spawn", "chunk", "x", "y", "z"), &GroundClutter::should_spawn); + ClassDB::bind_method(D_METHOD("add_meshes_to", "mesher", "chunk", "x", "y", "z"), &GroundClutter::add_meshes_to); + ClassDB::bind_method(D_METHOD("add_textures_to", "packer"), &GroundClutter::add_textures_to); +} diff --git a/clutter/ground_clutter.h b/clutter/ground_clutter.h new file mode 100644 index 0000000..694baf8 --- /dev/null +++ b/clutter/ground_clutter.h @@ -0,0 +1,52 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef GROUND_CLUTTER_H +#define GROUND_CLUTTER_H + +#include "core/resource.h" + +#include "../../texture_packer/texture_packer.h" +#include "../../voxelman/meshers/voxel_mesher.h" + +class VoxelChunk; +class VoxelMesher; + +class GroundClutter : public Resource { + GDCLASS(GroundClutter, Resource); + +public: + bool should_spawn(Ref chunk, int x, int y, int z); + + void add_meshes_to(Ref mesher, Ref chunk, int x, int y, int z); + void add_textures_to(Ref packer); + + GroundClutter(); + ~GroundClutter(); + +private: + static void _bind_methods(); + +private: +}; + +#endif diff --git a/clutter/ground_clutter_foliage.cpp b/clutter/ground_clutter_foliage.cpp new file mode 100644 index 0000000..d111607 --- /dev/null +++ b/clutter/ground_clutter_foliage.cpp @@ -0,0 +1,54 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "ground_clutter_foliage.h" + +int GroundClutterFoliage::get_texture_count() const { + return _textures.size(); +} +Ref GroundClutterFoliage::get_texture(const int index) { + ERR_FAIL_INDEX_V(index, _textures.size(), Ref()); + + return _textures.get(index); +} +void GroundClutterFoliage::remove_texture(const int index) { + ERR_FAIL_INDEX(index, _textures.size()); + + _textures.remove(index); +} +void GroundClutterFoliage::add_texture(Ref texture) { + _textures.push_back(texture); +} + +GroundClutterFoliage::GroundClutterFoliage() { +} + +GroundClutterFoliage::~GroundClutterFoliage() { + _textures.clear(); +} + +void GroundClutterFoliage::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_texture_count"), &GroundClutterFoliage::get_texture_count); + ClassDB::bind_method(D_METHOD("get_texture", "index"), &GroundClutterFoliage::get_texture); + ClassDB::bind_method(D_METHOD("remove_texture", "index"), &GroundClutterFoliage::remove_texture); + ClassDB::bind_method(D_METHOD("add_texture", "texture"), &GroundClutterFoliage::add_texture); +} diff --git a/clutter/ground_clutter_foliage.h b/clutter/ground_clutter_foliage.h new file mode 100644 index 0000000..10ee575 --- /dev/null +++ b/clutter/ground_clutter_foliage.h @@ -0,0 +1,51 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef GROUND_CLUTTER_FOLIAGE_H +#define GROUND_CLUTTER_FOLIAGE_H + +#include "ground_clutter.h" + +#include "core/vector.h" + +#include "scene/resources/texture.h" + +class GroundClutterFoliage : public GroundClutter { + GDCLASS(GroundClutterFoliage, GroundClutter); + +public: + int get_texture_count() const; + Ref get_texture(const int index); + void remove_texture(const int index); + void add_texture(Ref texture); + + GroundClutterFoliage(); + ~GroundClutterFoliage(); + +private: + static void _bind_methods(); + +private: + Vector > _textures; +}; + +#endif diff --git a/config.py b/config.py new file mode 100644 index 0000000..1086867 --- /dev/null +++ b/config.py @@ -0,0 +1,35 @@ + + +def can_build(env, platform): + return True + + +def configure(env): + pass + + +def get_doc_classes(): + return [ + + "GroundClutterFoliage", + "GroundClutter", + + "PropDataEntity", + "PropDataEntry", + "PropDataLight", + "PropDataMesh", + "PropDataProp", + "PropDataScene", + "PropData", + + "PropTool", + "PropToolEntity", + "PropToolLight", + "PropToolMesh", + "PropToolProp", + "PropToolScene", + ] + +def get_doc_path(): + return "doc_classes" + diff --git a/prop_tool/prop_tool.cpp b/prop_tool/prop_tool.cpp new file mode 100644 index 0000000..282b45e --- /dev/null +++ b/prop_tool/prop_tool.cpp @@ -0,0 +1,213 @@ +#include "prop_tool.h" + +#ifdef TOOLS_ENABLED + +#include "../props/prop_data.h" +#include "../props/prop_data_entity.h" +#include "../props/prop_data_light.h" +#include "../props/prop_data_mesh.h" +#include "../props/prop_data_prop.h" +#include "../props/prop_data_scene.h" + +#include "prop_tool_entity.h" +#include "prop_tool_light.h" +#include "prop_tool_mesh.h" +#include "prop_tool_prop.h" +#include "prop_tool_scene.h" + +#include "core/io/resource_saver.h" +#include "prop_tool_editor_plugin.h" + +void PropTool::edit(const Ref &prop) { +} + +void PropTool::save() { + if (!_target_prop.is_valid()) + return; + + print_verbose("save " + _target_prop->get_path()); + + while (_target_prop->get_prop_count() > 0) + _target_prop->remove_prop(0); + + for (int i = 0; i < get_child_count(); ++i) { + save_node(get_child(i), get_transform()); + } + + _target_prop->set_snap_to_mesh(_snap_to_mesh); + _target_prop->set_snap_axis(_snap_axis); + + ResourceSaver::save(_target_prop->get_path(), _target_prop); +} + +void PropTool::save_node(Node *node, Transform parent_transform) { + Spatial *snode = Object::cast_to(node); + + if (ObjectDB::instance_validate(snode) && snode->has_method("get_data")) { + Ref prop = node->call("get_data"); + + if (prop.is_valid()) { + prop->set_transform(parent_transform * snode->get_transform()); + + _target_prop->add_prop(prop); + } + + if (snode->has_method("evaluate_children") && !snode->call("evaluate_children")) + return; + + for (int i = 0; i < get_child_count(); ++i) { + save_node(get_child(i), parent_transform * snode->get_transform()); + } + } else { + if (node->has_method("set_target_prop") && node->has_method("get_target_prop")) { + Ref tprop = node->call("get_target_prop"); + + if (tprop.is_valid()) { + Ref prop; + prop.instance(); + + prop->set_prop(tprop); + + prop->set_transform(parent_transform * snode->get_transform()); + + _target_prop->add_prop(prop); + } + } else { + for (int i = 0; i < get_child_count(); ++i) { + save_node(get_child(i), parent_transform * snode->get_transform()); + } + } + } +} + +void PropTool::rebuild_hierarchy() { + for (int i = 0; i < get_child_count(); ++i) + get_child(i)->queue_delete(); + + if (!_target_prop.is_valid()) + return; + + _snap_to_mesh = _target_prop->get_snap_to_mesh(); + _snap_axis = _target_prop->get_snap_axis(); + + for (int i = 0; i < _target_prop->get_prop_count(); ++i) { + Ref prop = _target_prop->get_prop(i); + + Ref prop_light = prop; + Ref prop_mesh = prop; + Ref prop_scene = prop; + Ref prop_prop = prop; + Ref prop_entity = prop; + + if (prop_light.is_valid()) { + PropToolLight *l = memnew(PropToolLight); + + add_child(l); + l->set_owner(this); + l->set_transform(prop->get_transform()); + + l->set_data(prop_light); + } else if (prop_mesh.is_valid()) { + PropToolMesh *m = memnew(PropToolMesh); + + add_child(m); + m->set_owner(this); + m->set_transform(prop->get_transform()); + + m->set_data(prop_mesh); + } else if (prop_scene.is_valid()) { + PropToolScene *s = memnew(PropToolScene); + + add_child(s); + s->set_owner(this); + s->set_transform(prop->get_transform()); + + s->set_data(prop_scene); + } else if (prop_prop.is_valid()) { + PropTool *s = _plugin->create_or_get_scene(prop_prop->get_prop()); + + add_child(s); + s->set_owner(this); + s->set_transform(prop->get_transform()); + s->set_target_prop(prop_prop->get_prop()); + } else if (prop_entity.is_valid()) { + PropToolEntity *s = memnew(PropToolEntity); + + add_child(s); + s->set_owner(this); + s->set_transform(prop->get_transform()); + + s->set_data(prop_entity); + } + } +} + +void PropTool::refresh_set(bool value) { + if (value) + rebuild_hierarchy(); +} + +void PropTool::set_target_prop(const Ref &prop) { + _target_prop = prop; + + rebuild_hierarchy(); +} + +void PropTool::target_prop_set(const Ref &prop) { + _target_prop = prop; + + if (!prop.is_valid()) + return; + + PropTool *last_prop_tool = this; + Node *root = this; + + while (root->get_parent() != NULL) { + root = root->get_parent(); + + if (root && root->has_method("target_prop_set")) + last_prop_tool = Object::cast_to(root); + } + + if (last_prop_tool == this) + return; + + last_prop_tool->load_scene_for(this, prop); +} + +void PropTool::load_scene_for(PropTool *t, const Ref &prop) { + if (_plugin == NULL) + return; + + t->queue_delete(); + + Node *s = _plugin->create_or_get_scene(prop); + + add_child(s); + //s->set_owner(this); +} + +PropToolEditorPlugin *PropTool::get_plugin() { + return _plugin; +} + +void PropTool::set_plugin(PropToolEditorPlugin *plugin) { + _plugin = plugin; +} + +PropTool::PropTool() { + _snap_to_mesh = false; + _snap_axis = Vector3(0, -1, 0); +} +PropTool::PropTool(EditorNode *p_editor) { + _snap_to_mesh = false; + _snap_axis = Vector3(0, -1, 0); +} +PropTool::~PropTool() { + _target_prop.unref(); +} + +void PropTool::_bind_methods() { +} + +#endif \ No newline at end of file diff --git a/prop_tool/prop_tool.h b/prop_tool/prop_tool.h new file mode 100644 index 0000000..2255fc8 --- /dev/null +++ b/prop_tool/prop_tool.h @@ -0,0 +1,71 @@ +/* +Copyright (c) 2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_TOOL_H +#define PROP_TOOL_H + +class EditorNode; +class EditorPlugin; +class PropData; + +#include "core/math/vector3.h" +#include "core/reference.h" +#include "scene/3d/spatial.h" + +class propData; +class PropToolEditorPlugin; + +class PropTool : public Spatial { + GDCLASS(PropTool, Spatial); + +#ifdef TOOLS_ENABLED +public: + void edit(const Ref &prop); + + void save(); + void save_node(Node *node, Transform parent_transform); + void rebuild_hierarchy(); + void refresh_set(bool value); + void set_target_prop(const Ref &prop); + void target_prop_set(const Ref &prop); + void load_scene_for(PropTool *t, const Ref &prop); + + PropToolEditorPlugin *get_plugin(); + void set_plugin(PropToolEditorPlugin *plugin); + + PropTool(); + PropTool(EditorNode *p_editor); + ~PropTool(); + +protected: + static void _bind_methods(); + +private: + bool _refresh; + Ref _target_prop; + bool _snap_to_mesh; + Vector3 _snap_axis; + PropToolEditorPlugin *_plugin; +#endif +}; + +#endif diff --git a/prop_tool/prop_tool_editor_plugin.cpp b/prop_tool/prop_tool_editor_plugin.cpp new file mode 100644 index 0000000..4df37bb --- /dev/null +++ b/prop_tool/prop_tool_editor_plugin.cpp @@ -0,0 +1,340 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_tool_editor_plugin.h" + +#include "core/os/dir_access.h" +#include "core/os/file_access.h" +#include "editor/editor_scale.h" +#include "editor/editor_settings.h" +#include "scene/resources/packed_scene.h" + +#include "../props/prop_data.h" + +#include "prop_tool.h" +#include "prop_tool_entity.h" +#include "prop_tool_light.h" +#include "prop_tool_mesh.h" +#include "prop_tool_scene.h" + +#include "editor/plugins/spatial_editor_plugin.h" + +void PropToolEditorPlugin::edit(Object *p_object) { + Ref pedited_prop(Object::cast_to(p_object)); + + String p = create_or_get_scene_path(pedited_prop); + + get_editor_interface()->open_scene_from_path(p); +} + +bool PropToolEditorPlugin::handles(Object *p_object) const { + + bool handles = p_object->is_class("PropData"); + + return handles; +} + +void PropToolEditorPlugin::make_visible(bool p_visible) { +} + +String PropToolEditorPlugin::create_or_get_scene_path(const Ref &data) { + ERR_FAIL_COND_V(!data.is_valid(), ""); + + String temp_path = EditorSettings::get_singleton()->get("editors/prop_tool/temp_path"); + + String path = temp_path + data->get_path().get_file().get_basename() + ".tscn"; + + if (!FileAccess::exists(path)) + create_scene(data); + + return path; +} +PropTool *PropToolEditorPlugin::create_or_get_scene(const Ref &data) { + ERR_FAIL_COND_V(!data.is_valid(), NULL); + + String temp_path = EditorSettings::get_singleton()->get("editors/prop_tool/temp_path"); + + String path = temp_path + data->get_path().get_file().get_basename() + ".tscn"; + + Ref ps; + + if (!FileAccess::exists(path)) + ps = create_scene(data); + else + ps = ResourceLoader::load(path, "PackedScene"); + + if (!ps.is_valid()) + return NULL; + + PropTool *pt = Object::cast_to(ps->instance()); + pt->set_plugin(this); + return pt; +} +Ref PropToolEditorPlugin::create_scene(const Ref &data) { + PropTool *pt = memnew(PropTool); + + pt->set_plugin(this); + pt->set_target_prop(data); + + Ref ps; + ps.instance(); + ps->pack(pt); + + String temp_path = EditorSettings::get_singleton()->get("editors/prop_tool/temp_path"); + + Error err = ResourceSaver::save(temp_path + data->get_path().get_file().get_basename() + ".tscn", ps); + + if (err) + print_error("PropTool: create_scene failed! Error_code:" + String::num(err)); + + pt->queue_delete(); + return ps; +} + +void PropToolEditorPlugin::on_scene_changed(Node *scene) { + PropTool *pt = Object::cast_to(scene); + + if (ObjectDB::instance_validate(pt)) { + pt->set_plugin(this); + + light_button->show(); + mesh_button->show(); + prop_button->show(); + scene_button->show(); + entity_button->show(); + } else { + light_button->hide(); + mesh_button->hide(); + prop_button->hide(); + scene_button->hide(); + entity_button->hide(); + } +} + +void PropToolEditorPlugin::apply_changes() { + Node *scene = get_editor_interface()->get_edited_scene_root(); + PropTool *pt = Object::cast_to(scene); + + if (ObjectDB::instance_validate(pt)) { + pt->save(); + } +} + +void PropToolEditorPlugin::add_light() { + Array selection = get_editor_interface()->get_selection()->get_selected_nodes(); + + Node *selected; + + if (selection.size() != 1) + selected = get_editor_interface()->get_edited_scene_root(); + else + selected = selection[0]; + + Node *s = selected; + PropToolLight *n = memnew(PropToolLight); + + UndoRedo u = get_undo_redo(); + u.create_action("Add Light"); + u.add_do_method(s, "add_child", n); + u.add_do_property(n, "owner", get_editor_interface()->get_edited_scene_root()); + u.add_undo_method(s, "remove_child", n); + u.commit_action(); + + get_editor_interface()->get_selection()->clear(); + get_editor_interface()->get_selection()->add_node(n); +} + +void PropToolEditorPlugin::add_mesh() { + Array selected = get_editor_interface()->get_selection()->get_selected_nodes(); + + if (selected.size() != 1) + return; + + Node *s = selected[0]; + PropToolMesh *n = memnew(PropToolMesh); + + UndoRedo u = get_undo_redo(); + u.create_action("Add Mesh"); + u.add_do_method(s, "add_child", n); + u.add_do_property(n, "owner", get_editor_interface()->get_edited_scene_root()); + u.add_undo_method(s, "remove_child", n); + u.commit_action(); + + get_editor_interface()->get_selection()->clear(); + get_editor_interface()->get_selection()->add_node(n); +} + +void PropToolEditorPlugin::add_prop() { + + Array selected = get_editor_interface()->get_selection()->get_selected_nodes(); + + if (selected.size() != 1) + return; + + Node *s = selected[0]; + PropTool *n = memnew(PropTool); + + UndoRedo u = get_undo_redo(); + u.create_action("Add Prop"); + u.add_do_method(s, "add_child", n); + u.add_do_property(n, "owner", get_editor_interface()->get_edited_scene_root()); + u.add_undo_method(s, "remove_child", n); + u.commit_action(); + + get_editor_interface()->get_selection()->clear(); + get_editor_interface()->get_selection()->add_node(n); +} + +void PropToolEditorPlugin::add_scene() { + Array selected = get_editor_interface()->get_selection()->get_selected_nodes(); + + if (selected.size() != 1) + return; + + Node *s = selected[0]; + PropToolScene *n = memnew(PropToolScene); + + UndoRedo u = get_undo_redo(); + u.create_action("Add Scene"); + u.add_do_method(s, "add_child", n); + u.add_do_property(n, "owner", get_editor_interface()->get_edited_scene_root()); + u.add_undo_method(s, "remove_child", n); + u.commit_action(); + + get_editor_interface()->get_selection()->clear(); + get_editor_interface()->get_selection()->add_node(n); +} + +void PropToolEditorPlugin::add_entity() { + Array selected = get_editor_interface()->get_selection()->get_selected_nodes(); + + if (selected.size() != 1) + return; + + Node *s = selected[0]; + PropToolEntity *n = memnew(PropToolEntity); + + UndoRedo u = get_undo_redo(); + u.create_action("Add Entity"); + u.add_do_method(s, "add_child", n); + u.add_do_property(n, "owner", get_editor_interface()->get_edited_scene_root()); + u.add_undo_method(s, "remove_child", n); + u.commit_action(); + + get_editor_interface()->get_selection()->clear(); + get_editor_interface()->get_selection()->add_node(n); +} + +PropToolEditorPlugin::PropToolEditorPlugin(EditorNode *p_node) { + EDITOR_DEF("editors/prop_tool/temp_path", "res://.prop_tool_temp/"); + EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING, "editors/prop_tool/temp_path")); + + String tp = EditorSettings::get_singleton()->get("editors/prop_tool/temp_path"); + + if (!tp.ends_with("/")) { + tp += "/"; + EditorSettings::get_singleton()->set("editors/prop_tool/temp_path", tp); + } + + if (!DirAccess::exists(tp)) { + DirAccess *d = DirAccess::create_for_path(tp); + + Error err = d->make_dir_recursive(tp); + + memdelete(d); + + if (err) + print_error("PropTool: Temporary directory creation failed: error code: " + String::num(err)); + } + + editor = p_node; + + light_button = memnew(ToolButton); + light_button->set_text("Light"); + light_button->connect("pressed", this, "add_light"); + + mesh_button = memnew(ToolButton); + mesh_button->set_text("Mesh"); + mesh_button->connect("pressed", this, "add_mesh"); + + prop_button = memnew(ToolButton); + prop_button->set_text("Prop"); + prop_button->connect("pressed", this, "add_prop"); + + scene_button = memnew(ToolButton); + scene_button->set_text("Scene"); + scene_button->connect("pressed", this, "add_scene"); + + entity_button = memnew(ToolButton); + entity_button->set_text("Entity"); + entity_button->connect("pressed", this, "add_entity"); + + add_control_to_container(EditorPlugin::CONTAINER_SPATIAL_EDITOR_MENU, light_button); + add_control_to_container(EditorPlugin::CONTAINER_SPATIAL_EDITOR_MENU, mesh_button); + add_control_to_container(EditorPlugin::CONTAINER_SPATIAL_EDITOR_MENU, prop_button); + add_control_to_container(EditorPlugin::CONTAINER_SPATIAL_EDITOR_MENU, scene_button); + add_control_to_container(EditorPlugin::CONTAINER_SPATIAL_EDITOR_MENU, entity_button); + + light_button->hide(); + mesh_button->hide(); + prop_button->hide(); + scene_button->hide(); + entity_button->hide(); + + call_deferred("connect", "scene_changed", this, "on_scene_changed"); +} + +PropToolEditorPlugin::~PropToolEditorPlugin() { + _edited_prop.unref(); +} + +void PropToolEditorPlugin::_notification(int p_what) { + if (p_what == EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED) { + + String tp = EditorSettings::get_singleton()->get("editors/prop_tool/temp_path"); + + if (!tp.ends_with("/")) { + tp += "/"; + EditorSettings::get_singleton()->set("editors/prop_tool/temp_path", tp); + } + + if (!DirAccess::exists(tp)) { + DirAccess *d = DirAccess::create_for_path(tp); + + Error err = d->make_dir_recursive(tp); + + memdelete(d); + + ERR_FAIL_COND_MSG(err, "PropTool: Temporary directory creation failed: error code: " + String::num(err)); + } + } +} + +void PropToolEditorPlugin::_bind_methods() { + ClassDB::bind_method(D_METHOD("on_scene_changed", "scene_root"), &PropToolEditorPlugin::on_scene_changed); + ClassDB::bind_method(D_METHOD("apply_changes"), &PropToolEditorPlugin::apply_changes); + ClassDB::bind_method(D_METHOD("add_light"), &PropToolEditorPlugin::add_light); + ClassDB::bind_method(D_METHOD("add_mesh"), &PropToolEditorPlugin::add_mesh); + ClassDB::bind_method(D_METHOD("add_prop"), &PropToolEditorPlugin::add_prop); + ClassDB::bind_method(D_METHOD("add_scene"), &PropToolEditorPlugin::add_scene); + ClassDB::bind_method(D_METHOD("add_entity"), &PropToolEditorPlugin::add_entity); +} diff --git a/prop_tool/prop_tool_editor_plugin.h b/prop_tool/prop_tool_editor_plugin.h new file mode 100644 index 0000000..494a6c4 --- /dev/null +++ b/prop_tool/prop_tool_editor_plugin.h @@ -0,0 +1,75 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_TOOL_EDITOR_PLUGIN_H +#define PROP_TOOL_EDITOR_PLUGIN_H + +#include "editor/editor_node.h" +#include "editor/editor_plugin.h" + +class PropData; +class PropTool; + +class PropToolEditorPlugin : public EditorPlugin { + GDCLASS(PropToolEditorPlugin, EditorPlugin); + +public: + virtual String get_name() const { return "PropData"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_object); + virtual bool handles(Object *p_object) const; + virtual void make_visible(bool p_visible); + + String create_or_get_scene_path(const Ref &data); + PropTool *create_or_get_scene(const Ref &data); + Ref create_scene(const Ref &data); + + void on_scene_changed(Node *scene); + void apply_changes(); + void add_light(); + void add_mesh(); + void add_prop(); + void add_scene(); + void add_entity(); + + PropToolEditorPlugin(EditorNode *p_node); + ~PropToolEditorPlugin(); + +protected: + void _notification(int p_what); + static void _bind_methods(); + +private: + ToolButton *light_button; + ToolButton *mesh_button; + ToolButton *prop_button; + ToolButton *scene_button; + ToolButton *entity_button; + + ToolButton *edited_prop; + + EditorNode *editor; + + Ref _edited_prop; +}; + +#endif diff --git a/prop_tool/prop_tool_entity.cpp b/prop_tool/prop_tool_entity.cpp new file mode 100644 index 0000000..d382307 --- /dev/null +++ b/prop_tool/prop_tool_entity.cpp @@ -0,0 +1,152 @@ +/* +Copyright (c) 2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_tool_entity.h" + +#ifdef TOOLS_ENABLED + +#include "../../entity_spell_system/entities/data/entity_data.h" +#include "../../entity_spell_system/entities/entity.h" + +Ref PropToolEntity::get_data() { + if (!is_visible() || !_entity_data.is_valid()) + return Ref(); + + if (!_prop_entity.is_valid()) + _prop_entity.instance(); + + _prop_entity->set_entity_data_id(_entity_data_id); + _prop_entity->set_level(_level); + + return _prop_entity; +} +void PropToolEntity::set_data(const Ref &data) { + _prop_entity = data; + + if (!_prop_entity.is_valid()) + return; + + _entity_data_id = _prop_entity->get_entity_data_id(); + _level = _prop_entity->get_level(); + + /* + TODO generic solution + var dir = Directory.new() + if dir.open("res://data/entities/") == OK: + dir.list_dir_begin() + var file_name = dir.get_next() + + while (file_name != ""): + if not dir.current_is_dir(): + var ed : EntityData = ResourceLoader.load("res://data/entities/" + file_name, "EntityData") + + if ed != null and ed.id == entity_data_id: + set_entity_data(ed) + return + + file_name = dir.get_next() + + print("PropToolEntity: Entity not found!") + */ +} + +Ref PropToolEntity::get_entity_data() { + return _entity_data; +} +void PropToolEntity::set_entity_data(const Ref &data) { + _entity_data = data; + + if (!_entity_data.is_valid()) + return; + + _entity_data_id = _entity_data->get_id(); + + if (_entity == NULL) { + //TODO generic solutiuon + + //var scene : PackedScene = load("res://addons/prop_tool/player/PropToolDisplayPlayer.tscn") + + //_entity = scene.instance() as Entity + + // add_child(_entity) + //_entity.owner = owner + + //_entity.get_node(_entity.character_skeleton_path).owner = owner + //_entity.get_node(_entity.character_skeleton_path).refresh_in_editor = true + //_entity.get_character_skeleton().refresh_in_editor = true + + // _entity.sentity_data = entity_data + + //name = entity_data.text_name + } +} + +int PropToolEntity::get_entity_data_id() const { + return _entity_data_id; +} +void PropToolEntity::set_entity_data_id(const int value) { + _entity_data_id = value; +} + +int PropToolEntity::get_level() const { + return _level; +} +void PropToolEntity::set_level(const int value) { + _level = value; +} + +bool PropToolEntity::evaluate_children() const { + return false; +} + +PropToolEntity::PropToolEntity() { + _entity_data_id = 0; + _level = 1; + + _entity = NULL; +} +PropToolEntity::~PropToolEntity() { + _entity_data.unref(); + _prop_entity.unref(); +} + +void PropToolEntity::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_data"), &PropToolEntity::get_data); + ClassDB::bind_method(D_METHOD("set_data", "value"), &PropToolEntity::set_data); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "PropDataProp"), "set_data", "get_data"); + + ClassDB::bind_method(D_METHOD("get_entity_data_id"), &PropToolEntity::get_entity_data_id); + ClassDB::bind_method(D_METHOD("set_entity_data_id", "value"), &PropToolEntity::set_entity_data_id); + ADD_PROPERTY(PropertyInfo(Variant::INT, "entity_data_id"), "set_entity_data_id", "get_entity_data_id"); + + ClassDB::bind_method(D_METHOD("get_level"), &PropToolEntity::get_level); + ClassDB::bind_method(D_METHOD("set_level", "value"), &PropToolEntity::set_level); + ADD_PROPERTY(PropertyInfo(Variant::INT, "level"), "set_level", "get_level"); + + ClassDB::bind_method(D_METHOD("get_entity_data"), &PropToolEntity::get_entity_data); + ClassDB::bind_method(D_METHOD("set_entity_data", "value"), &PropToolEntity::set_entity_data); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "entity_data", PROPERTY_HINT_RESOURCE_TYPE, "EntityData"), "set_entity_data", "get_entity_data"); + + ClassDB::bind_method(D_METHOD("evaluate_children"), &PropToolEntity::evaluate_children); +} + +#endif \ No newline at end of file diff --git a/prop_tool/prop_tool_entity.h b/prop_tool/prop_tool_entity.h new file mode 100644 index 0000000..31a2d09 --- /dev/null +++ b/prop_tool/prop_tool_entity.h @@ -0,0 +1,69 @@ +/* +Copyright (c) 2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_TOOL_ENTITY_H +#define PROP_TOOL_ENTITY_H + +#include "scene/3d/spatial.h" + +#include "../props/prop_data.h" +#include "../props/prop_data_entity.h" + +class EntityData; +class Entity; + +class PropToolEntity : public Spatial { + GDCLASS(PropToolEntity, Spatial); + +#ifdef TOOLS_ENABLED +public: + Ref get_data(); + void set_data(const Ref &data); + + Ref get_entity_data(); + void set_entity_data(const Ref &data); + + int get_entity_data_id() const; + void set_entity_data_id(const int value); + + int get_level() const; + void set_level(const int value); + + bool evaluate_children() const; + + PropToolEntity(); + ~PropToolEntity(); + +protected: + static void _bind_methods(); + +private: + Ref _entity_data; + int _entity_data_id; + int _level; + + Ref _prop_entity; + Entity *_entity; +#endif +}; + +#endif diff --git a/prop_tool/prop_tool_light.cpp b/prop_tool/prop_tool_light.cpp new file mode 100644 index 0000000..274c9c9 --- /dev/null +++ b/prop_tool/prop_tool_light.cpp @@ -0,0 +1,74 @@ +/* +Copyright (c) 2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_tool_light.h" + +#ifdef TOOLS_ENABLED + +Ref PropToolLight::get_data() { + + if (!is_visible()) + return Ref(); + + if (!_prop_light.is_valid()) + _prop_light.instance(); + + _prop_light->set_light_color(get_color()); + _prop_light->set_light_size(get_param(Light::PARAM_RANGE)); + + return _prop_light; +} +void PropToolLight::set_data(const Ref &data) { + _prop_light = data; + + if (!_prop_light.is_valid()) + return; + + set_color(_prop_light->get_light_color()); + set_param(Light::PARAM_RANGE, _prop_light->get_light_size()); + set_param(Light::PARAM_ENERGY, _prop_light->get_light_size()); +} + +bool PropToolLight::get_snap_to_mesh() const { + return _snap_to_mesh; +} +void PropToolLight::set_snap_to_mesh(const bool value) { + _snap_to_mesh = value; +} + +PropToolLight::PropToolLight() { +} +PropToolLight::~PropToolLight() { + _prop_light.unref(); +} + +void PropToolLight::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_data"), &PropToolLight::get_data); + ClassDB::bind_method(D_METHOD("set_data", "value"), &PropToolLight::set_data); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "PropDataLight"), "set_data", "get_data"); + + ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropToolLight::get_snap_to_mesh); + ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropToolLight::set_snap_to_mesh); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_snap_to_mesh"); +} + +#endif \ No newline at end of file diff --git a/prop_tool/prop_tool_light.h b/prop_tool/prop_tool_light.h new file mode 100644 index 0000000..8e9c0ac --- /dev/null +++ b/prop_tool/prop_tool_light.h @@ -0,0 +1,58 @@ +/* +Copyright (c) 2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_TOOL_LIGHT_H +#define PROP_TOOL_LIGHT_H + +class EditorNode; +class EditorPlugin; +class PropData; + +#include "../props/prop_data_light.h" +#include "scene/3d/light.h" + +class propData; + +class PropToolLight : public OmniLight { + GDCLASS(PropToolLight, OmniLight); + +#ifdef TOOLS_ENABLED +public: + Ref get_data(); + void set_data(const Ref &data); + + bool get_snap_to_mesh() const; + void set_snap_to_mesh(const bool value); + + PropToolLight(); + ~PropToolLight(); + +protected: + static void _bind_methods(); + +private: + Ref _prop_light; + bool _snap_to_mesh; +#endif +}; + +#endif diff --git a/prop_tool/prop_tool_mesh.cpp b/prop_tool/prop_tool_mesh.cpp new file mode 100644 index 0000000..33f09cf --- /dev/null +++ b/prop_tool/prop_tool_mesh.cpp @@ -0,0 +1,183 @@ +/* +Copyright (c) 2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_tool_mesh.h" + +#ifdef TOOLS_ENABLED + +Ref PropToolMesh::get_mesh_data() { + return _mesh_data; +} +void PropToolMesh::set_mesh_data(const Ref &data) { + _mesh_data = data; +} + +Ref PropToolMesh::get_data() { + return _prop_mesh; + + if (!is_visible() || !_mesh_data.is_valid()) + return Ref(); + + if (!_prop_mesh.is_valid()) + _prop_mesh.instance(); + + _prop_mesh->set_mesh(_mesh_data); + _prop_mesh->set_texture(_texture); + _prop_mesh->set_snap_to_mesh(_snap_to_mesh); + _prop_mesh->set_snap_axis(_snap_axis); + + return _prop_mesh; +} +void PropToolMesh::set_data(const Ref &data) { + _prop_mesh = data; + + if (!_prop_mesh.is_valid()) + return; + + _texture = _prop_mesh->get_texture(); + + _snap_to_mesh = _prop_mesh->get_snap_to_mesh(); + _snap_axis = _prop_mesh->get_snap_axis(); + + set_generate(true); +} + +Ref PropToolMesh::get_texture() { + return _texture; +} +void PropToolMesh::set_texture(const Ref &tex) { + _texture = tex; +} + +bool PropToolMesh::get_snap_to_mesh() const { + return _snap_to_mesh; +} +void PropToolMesh::set_snap_to_mesh(const bool value) { + _snap_to_mesh = value; +} + +Vector3 PropToolMesh::get_snap_axis() const { + return _snap_axis; +} +void PropToolMesh::set_snap_axis(const Vector3 &value) { + _snap_axis = value; +} + +Ref PropToolMesh::get_prop_mesh() { + return _prop_mesh; +} +void PropToolMesh::set_prop_mesh(const Ref &data) { + _prop_mesh = data; +} + +void PropToolMesh::generate() { +} + +PropToolMesh::PropToolMesh() { + _snap_to_mesh = false; + _snap_axis = Vector3(0, -1, 0); +} +PropToolMesh::~PropToolMesh() { + _prop_mesh.unref(); + _material.unref(); +} + +void PropToolMesh::set_generate(bool value) { + if (!value) + return; + + if (!_mesh_data.is_valid()) { + mesh.unref(); + return; + } + + Ref m; + m.instance(); + + Array arr; + arr.resize(ArrayMesh::ARRAY_MAX); + + Array mda = _mesh_data->get_array(); + + PoolVector3Array v; + v.append_array(mda[Mesh::ARRAY_VERTEX]); + arr.set(Mesh::ARRAY_VERTEX, v); + + PoolVector3Array norm; + norm.append_array(mda[Mesh::ARRAY_NORMAL]); + arr.set(Mesh::ARRAY_NORMAL, norm); + + PoolVector2Array uv; + uv.append_array(mda[Mesh::ARRAY_TEX_UV]); + arr.set(Mesh::ARRAY_TEX_UV, uv); + + PoolIntArray ind; + ind.append_array(mda[Mesh::ARRAY_INDEX]); + arr.set(Mesh::ARRAY_INDEX, ind); + + m->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, arr); + + mesh = m; + + if (_texture.is_valid()) { + if (!_material.is_valid()) + _material.instance(); + + _material->set_texture(SpatialMaterial::TEXTURE_ALBEDO, _texture); + + set_material_override(_material); + } +} + +void PropToolMesh::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_mesh_data"), &PropToolMesh::get_mesh_data); + ClassDB::bind_method(D_METHOD("set_mesh_data", "value"), &PropToolMesh::set_mesh_data); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "mesh_data", PROPERTY_HINT_RESOURCE_TYPE, "MeshDataResource"), "set_mesh_data", "get_mesh_data"); + + ClassDB::bind_method(D_METHOD("get_data"), &PropToolMesh::get_data); + ClassDB::bind_method(D_METHOD("set_data", "value"), &PropToolMesh::set_data); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "PropDataMesh"), "set_data", "get_data"); + + ClassDB::bind_method(D_METHOD("get_texture"), &PropToolMesh::get_texture); + ClassDB::bind_method(D_METHOD("set_texture", "value"), &PropToolMesh::set_texture); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture"); + + ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropToolMesh::get_snap_to_mesh); + ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropToolMesh::set_snap_to_mesh); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_snap_to_mesh"); + + ClassDB::bind_method(D_METHOD("get_snap_axis"), &PropToolMesh::get_snap_axis); + ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropToolMesh::set_snap_axis); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis"); + + ClassDB::bind_method(D_METHOD("get_prop_mesh"), &PropToolMesh::get_prop_mesh); + ClassDB::bind_method(D_METHOD("set_prop_mesh", "value"), &PropToolMesh::set_prop_mesh); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "prop_mesh", PROPERTY_HINT_RESOURCE_TYPE, "MeshDataResource"), "set_prop_mesh", "get_prop_mesh"); + + ClassDB::bind_method(D_METHOD("generate"), &PropToolMesh::generate); + + ClassDB::bind_method(D_METHOD("get_generate"), &PropToolMesh::get_generate); + ClassDB::bind_method(D_METHOD("set_generate"), &PropToolMesh::set_generate); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "generate"), "set_generate", "get_generate"); +} + +#endif \ No newline at end of file diff --git a/prop_tool/prop_tool_mesh.h b/prop_tool/prop_tool_mesh.h new file mode 100644 index 0000000..9fa77f5 --- /dev/null +++ b/prop_tool/prop_tool_mesh.h @@ -0,0 +1,75 @@ +/* +Copyright (c) 2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_TOOL_MESH_H +#define PROP_TOOL_MESH_H + +#include "core/math/vector3.h" + +#include "../props/prop_data_mesh.h" +#include "scene/3d/mesh_instance.h" + +class PropToolMesh : public MeshInstance { + GDCLASS(PropToolMesh, MeshInstance); + +#ifdef TOOLS_ENABLED +public: + Ref get_mesh_data(); + void set_mesh_data(const Ref &data); + + Ref get_data(); + void set_data(const Ref &data); + + Ref get_texture(); + void set_texture(const Ref &tex); + + bool get_snap_to_mesh() const; + void set_snap_to_mesh(const bool value); + + Vector3 get_snap_axis() const; + void set_snap_axis(const Vector3 &value); + + Ref get_prop_mesh(); + void set_prop_mesh(const Ref &data); + + void generate(); + + PropToolMesh(); + ~PropToolMesh(); + +protected: + bool get_generate() { return false; } + void set_generate(bool value); + + static void _bind_methods(); + +private: + Ref _mesh_data; + Ref _prop_mesh; + Ref _texture; + Ref _material; + bool _snap_to_mesh; + Vector3 _snap_axis; +#endif +}; + +#endif diff --git a/prop_tool/prop_tool_prop.cpp b/prop_tool/prop_tool_prop.cpp new file mode 100644 index 0000000..5317e55 --- /dev/null +++ b/prop_tool/prop_tool_prop.cpp @@ -0,0 +1,99 @@ +/* +Copyright (c) 2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_tool_prop.h" + +#ifdef TOOLS_ENABLED + +Ref PropToolProp::get_data() { + if (!is_visible() || !_prop_data.is_valid()) + return Ref(); + + if (!_prop_data.is_valid()) + _prop_data.instance(); + + _prop_prop->set_prop(_prop_data); + _prop_prop->set_snap_to_mesh(_snap_to_mesh); + _prop_prop->set_snap_axis(_snap_axis); + + return _prop_prop; +} +void PropToolProp::set_data(const Ref &data) { + _prop_prop = data; + + if (!_prop_prop.is_valid()) + return; + + _prop_data = _prop_prop->get_prop(); + _snap_to_mesh = _prop_prop->get_snap_to_mesh(); + _snap_axis = _prop_prop->get_snap_axis(); +} + +Ref PropToolProp::get_prop_data() { + return _prop_data; +} +void PropToolProp::set_prop_data(const Ref &data) { + _prop_data = data; +} + +bool PropToolProp::get_snap_to_mesh() const { + return _snap_to_mesh; +} +void PropToolProp::set_snap_to_mesh(const bool value) { + _snap_to_mesh = value; +} + +Vector3 PropToolProp::get_snap_axis() const { + return _snap_axis; +} +void PropToolProp::set_snap_axis(const Vector3 &value) { + _snap_axis = value; +} + +PropToolProp::PropToolProp() { + _snap_to_mesh = false; + _snap_axis = Vector3(0, -1, 0); +} +PropToolProp::~PropToolProp() { + _prop_data.unref(); + _prop_prop.unref(); +} + +void PropToolProp::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_data"), &PropToolProp::get_data); + ClassDB::bind_method(D_METHOD("set_data", "value"), &PropToolProp::set_data); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "PropDataProp"), "set_data", "get_data"); + + ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropToolProp::get_snap_to_mesh); + ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropToolProp::set_snap_to_mesh); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_snap_to_mesh"); + + ClassDB::bind_method(D_METHOD("get_snap_axis"), &PropToolProp::get_snap_axis); + ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropToolProp::set_snap_axis); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis"); + + ClassDB::bind_method(D_METHOD("get_prop_data"), &PropToolProp::get_prop_data); + ClassDB::bind_method(D_METHOD("set_prop_data", "value"), &PropToolProp::set_prop_data); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "prop_data", PROPERTY_HINT_RESOURCE_TYPE, "PropData"), "set_prop_data", "get_prop_data"); +} + +#endif \ No newline at end of file diff --git a/prop_tool/prop_tool_prop.h b/prop_tool/prop_tool_prop.h new file mode 100644 index 0000000..c3d9d1a --- /dev/null +++ b/prop_tool/prop_tool_prop.h @@ -0,0 +1,62 @@ +/* +Copyright (c) 2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_TOOL_PROP_H +#define PROP_TOOL_PROP_H + +#include "scene/3d/spatial.h" + +#include "../props/prop_data.h" +#include "../props/prop_data_prop.h" + +class PropToolProp : public Spatial { + GDCLASS(PropToolProp, Spatial); + +#ifdef TOOLS_ENABLED +public: + Ref get_data(); + void set_data(const Ref &data); + + Ref get_prop_data(); + void set_prop_data(const Ref &data); + + bool get_snap_to_mesh() const; + void set_snap_to_mesh(const bool value); + + Vector3 get_snap_axis() const; + void set_snap_axis(const Vector3 &value); + + PropToolProp(); + ~PropToolProp(); + +protected: + static void _bind_methods(); + +private: + Ref _prop_data; + bool _snap_to_mesh; + Vector3 _snap_axis; + Ref _prop_prop; +#endif +}; + +#endif diff --git a/prop_tool/prop_tool_scene.cpp b/prop_tool/prop_tool_scene.cpp new file mode 100644 index 0000000..1e4bf24 --- /dev/null +++ b/prop_tool/prop_tool_scene.cpp @@ -0,0 +1,99 @@ +/* +Copyright (c) 2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_tool_scene.h" + +#ifdef TOOLS_ENABLED + +Ref PropToolScene::get_data() { + if (!is_visible() || !_scene_data.is_valid()) + return Ref(); + + if (!_prop_scene.is_valid()) + _prop_scene.instance(); + + _prop_scene->set_scene(_scene_data); + _prop_scene->set_snap_to_mesh(_snap_to_mesh); + _prop_scene->set_snap_axis(_snap_axis); + + return _prop_scene; +} +void PropToolScene::set_data(const Ref &data) { + _prop_scene = data; + + if (!_prop_scene.is_valid()) + return; + + _scene_data = _prop_scene->get_scene(); + _snap_to_mesh = _prop_scene->get_snap_to_mesh(); + _snap_axis = _prop_scene->get_snap_axis(); +} + +Ref PropToolScene::get_scene_data() { + return _scene_data; +} +void PropToolScene::set_scene_data(const Ref &data) { + _scene_data = data; +} + +bool PropToolScene::get_snap_to_mesh() const { + return _snap_to_mesh; +} +void PropToolScene::set_snap_to_mesh(const bool value) { + _snap_to_mesh = value; +} + +Vector3 PropToolScene::get_snap_axis() const { + return _snap_axis; +} +void PropToolScene::set_snap_axis(const Vector3 &value) { + _snap_axis = value; +} + +PropToolScene::PropToolScene() { + _snap_to_mesh = false; + _snap_axis = Vector3(0, -1, 0); +} +PropToolScene::~PropToolScene() { + _scene_data.unref(); + _prop_scene.unref(); +} + +void PropToolScene::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_data"), &PropToolScene::get_data); + ClassDB::bind_method(D_METHOD("set_data", "value"), &PropToolScene::set_data); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "PropDataScene"), "set_data", "get_data"); + + ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropToolScene::get_snap_to_mesh); + ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropToolScene::set_snap_to_mesh); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_snap_to_mesh"); + + ClassDB::bind_method(D_METHOD("get_snap_axis"), &PropToolScene::get_snap_axis); + ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropToolScene::set_snap_axis); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis"); + + ClassDB::bind_method(D_METHOD("get_scene_data"), &PropToolScene::get_scene_data); + ClassDB::bind_method(D_METHOD("set_scene_data", "value"), &PropToolScene::set_scene_data); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "scene_data", PROPERTY_HINT_RESOURCE_TYPE, "PackedScene"), "set_scene_data", "get_scene_data"); +} + +#endif \ No newline at end of file diff --git a/prop_tool/prop_tool_scene.h b/prop_tool/prop_tool_scene.h new file mode 100644 index 0000000..744d43a --- /dev/null +++ b/prop_tool/prop_tool_scene.h @@ -0,0 +1,61 @@ +/* +Copyright (c) 2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_TOOL_SCENE_H +#define PROP_TOOL_SCENE_H + +#include "scene/3d/spatial.h" + +#include "../props/prop_data_scene.h" + +class PropToolScene : public Spatial { + GDCLASS(PropToolScene, Spatial); + +#ifdef TOOLS_ENABLED +public: + Ref get_data(); + void set_data(const Ref &data); + + Ref get_scene_data(); + void set_scene_data(const Ref &data); + + bool get_snap_to_mesh() const; + void set_snap_to_mesh(const bool value); + + Vector3 get_snap_axis() const; + void set_snap_axis(const Vector3 &value); + + PropToolScene(); + ~PropToolScene(); + +protected: + static void _bind_methods(); + +private: + Ref _scene_data; + bool _snap_to_mesh; + Vector3 _snap_axis; + Ref _prop_scene; +#endif +}; + +#endif diff --git a/props/prop_data.cpp b/props/prop_data.cpp new file mode 100644 index 0000000..ce53d30 --- /dev/null +++ b/props/prop_data.cpp @@ -0,0 +1,264 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_data.h" + +#include "../../voxelman/world/voxel_chunk.h" +#include "prop_data_prop.h" + +int PropData::get_id() const { + return _id; +} +void PropData::set_id(const int value) { + _id = value; +} + +bool PropData::get_snap_to_mesh() const { + return _snap_to_mesh; +} +void PropData::set_snap_to_mesh(const bool value) { + _snap_to_mesh = value; +} + +Vector3 PropData::get_snap_axis() const { + return _snap_axis; +} +void PropData::set_snap_axis(const Vector3 &value) { + _snap_axis = value; +} + +Ref PropData::get_prop(const int index) const { + ERR_FAIL_INDEX_V(index, _props.size(), Ref()); + + return _props.get(index); +} +void PropData::set_prop(const int index, const Ref prop) { + ERR_FAIL_INDEX(index, _props.size()); + + _props.set(index, prop); +} +void PropData::add_prop(const Ref prop) { + _props.push_back(prop); +} +void PropData::remove_prop(const int index) { + ERR_FAIL_INDEX(index, _props.size()); + + _props.remove(index); +} + +int PropData::get_prop_count() const { + return _props.size(); +} + +Vector PropData::get_props() { + Vector r; + for (int i = 0; i < _props.size(); i++) { + r.push_back(_props[i].get_ref_ptr()); + } + return r; +} +void PropData::set_props(const Vector &props) { + _props.clear(); + for (int i = 0; i < props.size(); i++) { + Ref prop = Ref(props[i]); + + _props.push_back(prop); + } +} + +void PropData::add_textures_into(Ref texture_packer) { + ERR_FAIL_COND(!texture_packer.is_valid()); + + for (int i = 0; i < _props.size(); ++i) { + Ref entry = _props.get(i); + + Ref pmesh = entry; + + if (pmesh.is_valid() && pmesh->get_texture().is_valid()) { + texture_packer->add_texture(pmesh->get_texture()); + } + + Ref pdataprop = entry; + + if (pdataprop.is_valid() && pdataprop->get_prop().is_valid()) { + pdataprop->get_prop()->add_textures_into(texture_packer); + } + } +} + +void PropData::add_prop_lights_into(Ref chunk, Transform parent_transform, bool allow_snap) { + ERR_FAIL_COND(!chunk.is_valid()); + + for (int i = 0; i < _props.size(); ++i) { + Ref entry = _props.get(i); + + Ref pl = entry; + + if (pl.is_valid()) { + Transform t = parent_transform * pl->get_transform(); + + Vector3 px = t.origin / chunk->get_voxel_scale(); + + Ref vl; + vl.instance(); + vl->set_world_position(px.x + chunk->get_position_x() * chunk->get_size_x(), px.y + chunk->get_position_y() * chunk->get_size_y(), px.z + chunk->get_position_z() * chunk->get_size_z()); + vl->set_color(pl->get_light_color()); + vl->set_size(pl->get_light_size()); + + chunk->add_prop_light(vl); + } + + Ref pdataprop = entry; + + if (pdataprop.is_valid() && pdataprop->get_prop().is_valid()) { + Ref pd = pdataprop->get_prop(); + + if (allow_snap) { + if (pd->get_snap_to_mesh()) + print_error(pd->get_name()); + + pd->add_prop_lights_into(chunk, get_next_snapped_prop_transform(chunk->get_voxel_world(), parent_transform * pdataprop->get_transform(), pd->get_snap_to_mesh(), pd->get_snap_axis()), allow_snap); + } else { + pd->add_prop_lights_into(chunk, parent_transform * pdataprop->get_transform(), allow_snap); + } + } + } +} + +void PropData::add_meshes_into(Ref mesher, Ref texture_packer, Transform parent_transform, Spatial *snap_spatial) { + ERR_FAIL_COND(!mesher.is_valid()); + ERR_FAIL_COND(!texture_packer.is_valid()); + ERR_FAIL_COND(texture_packer->get_generated_texture_count() == 0); + ERR_FAIL_COND(snap_spatial != NULL && !ObjectDB::instance_validate(snap_spatial)); + + Vector2 texsize = texture_packer->get_generated_texture(0)->get_size(); + + for (int i = 0; i < _props.size(); ++i) { + Ref entry = _props.get(i); + + Ref pmesh = entry; + + if (pmesh.is_valid()) { + + Rect2 reg = Rect2(0, 0, 1, 1); + + if (pmesh->get_texture().is_valid()) { + + Ref at = texture_packer->get_texture(pmesh->get_texture()); + + reg = at->get_region(); + + reg.position.x /= texsize.x; + reg.position.y /= texsize.y; + reg.size.x /= texsize.x; + reg.size.y /= texsize.y; + } + + if (snap_spatial != NULL) + mesher->add_mesh_data_resource_transform(pmesh->get_mesh(), get_next_snapped_prop_transform(snap_spatial, parent_transform * pmesh->get_transform(), pmesh->get_snap_to_mesh(), pmesh->get_snap_axis()), reg); + else + mesher->add_mesh_data_resource_transform(pmesh->get_mesh(), parent_transform * pmesh->get_transform(), reg); + } + + Ref pdataprop = entry; + + if (pdataprop.is_valid() && pdataprop->get_prop().is_valid()) { + + if (snap_spatial != NULL) + pdataprop->get_prop()->add_meshes_into(mesher, texture_packer, get_next_snapped_prop_transform(snap_spatial, parent_transform * pdataprop->get_transform(), pdataprop->get_snap_to_mesh(), pdataprop->get_snap_axis()), snap_spatial); + else + pdataprop->get_prop()->add_meshes_into(mesher, texture_packer, parent_transform * pmesh->get_transform(), snap_spatial); + } + } +} +void PropData::add_meshes_into_bind(Ref mesher, Ref texture_packer, Transform parent_transform, Node *snap_spatial) { + Spatial *s = Object::cast_to(snap_spatial); + + ERR_FAIL_COND(s != NULL && !ObjectDB::instance_validate(s)); + + add_meshes_into(mesher, texture_packer, parent_transform, s); +} + +Transform PropData::get_next_snapped_prop_transform(Spatial *s, Transform parent_transform, bool snap_to_mesh, Vector3 snap_axis) { + if (snap_to_mesh) { + Vector3 pos = s->to_global(parent_transform.origin); + Vector3 world_snap_axis = s->to_global(parent_transform.xform(snap_axis)); + Vector3 world_snap_dir = world_snap_axis - pos; + world_snap_dir *= 100; + + PhysicsDirectSpaceState *space_state = s->get_world()->get_direct_space_state(); + + ERR_FAIL_COND_V(space_state == NULL, parent_transform); + + PhysicsDirectSpaceState::RayResult res; + + if (space_state->intersect_ray(pos - world_snap_dir, pos + world_snap_dir, res, Set(), 1)) { + parent_transform.origin = s->to_local(res.position); + } + } + + return parent_transform; +} +Transform PropData::get_next_snapped_prop_transform_bind(Node *spatial, Transform parent_transform, bool snap_to_mesh, Vector3 snap_axis) { + Spatial *s = Object::cast_to(spatial); + + ERR_FAIL_COND_V(!ObjectDB::instance_validate(s), parent_transform); + + return get_next_snapped_prop_transform(s, parent_transform, snap_to_mesh, snap_axis); +} + +PropData::PropData() { + _id = 0; + _snap_to_mesh = false; + _snap_axis = Vector3(0, -1, 0); +} +PropData::~PropData() { + _props.clear(); +} + +void PropData::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropData::get_snap_to_mesh); + ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropData::set_snap_to_mesh); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_snap_to_mesh"); + + ClassDB::bind_method(D_METHOD("get_snap_axis"), &PropData::get_snap_axis); + ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropData::set_snap_axis); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis"); + + ClassDB::bind_method(D_METHOD("get_prop", "index"), &PropData::get_prop); + ClassDB::bind_method(D_METHOD("set_prop", "index", "spell"), &PropData::set_prop); + ClassDB::bind_method(D_METHOD("add_prop", "prop"), &PropData::add_prop); + ClassDB::bind_method(D_METHOD("remove_prop", "index"), &PropData::remove_prop); + + ClassDB::bind_method(D_METHOD("get_prop_count"), &PropData::get_prop_count); + + ClassDB::bind_method(D_METHOD("get_props"), &PropData::get_props); + ClassDB::bind_method(D_METHOD("set_props", "props"), &PropData::set_props); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "props", PROPERTY_HINT_NONE, "17/17:PropDataEntry", PROPERTY_USAGE_DEFAULT, "PropDataEntry"), "set_props", "get_props"); + + ClassDB::bind_method(D_METHOD("add_textures_into", "texture_packer"), &PropData::add_textures_into); + ClassDB::bind_method(D_METHOD("add_prop_lights_into", "chunk", "parent_transform", "allow_snap"), &PropData::add_prop_lights_into); + + ClassDB::bind_method(D_METHOD("add_meshes_into", "mesher", "texture_packer", "parent_transform", "snap_spatial"), &PropData::add_meshes_into_bind); + + ClassDB::bind_method(D_METHOD("get_next_snapped_prop_transform", "spatial", "parent_transform", "snap_to_mesh", "snap_axis"), &PropData::get_next_snapped_prop_transform_bind); +} diff --git a/props/prop_data.h b/props/prop_data.h new file mode 100644 index 0000000..28d1e86 --- /dev/null +++ b/props/prop_data.h @@ -0,0 +1,90 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_DATA_H +#define PROP_DATA_H + +#include "core/math/rect2.h" +#include "core/math/transform.h" +#include "core/math/vector2.h" +#include "core/math/vector3.h" +#include "core/reference.h" +#include "core/vector.h" + +#include "servers/physics_server.h" + +#include "prop_data_entry.h" +#include "prop_data_mesh.h" + +#include "../../voxelman/meshers/voxel_mesher.h" + +#include "../../texture_packer/texture_packer.h" + +class Spatial; +class VoxelChunk; + +class PropData : public Resource { + GDCLASS(PropData, Resource); + +public: + int get_id() const; + void set_id(const int value); + + bool get_snap_to_mesh() const; + void set_snap_to_mesh(const bool value); + + Vector3 get_snap_axis() const; + void set_snap_axis(const Vector3 &value); + + Ref get_prop(const int index) const; + void set_prop(const int index, const Ref prop); + void add_prop(const Ref prop); + void remove_prop(const int index); + + int get_prop_count() const; + + Vector get_props(); + void set_props(const Vector &props); + + void add_textures_into(Ref texture_packer); + void add_prop_lights_into(Ref chunk, Transform parent_transform, bool allow_snap); + void add_meshes_into(Ref mesher, Ref texture_packer, Transform parent_transform, Spatial *snap_spatial = NULL); + void add_meshes_into_bind(Ref mesher, Ref texture_packer, Transform parent_transform, Node *snap_spatial = NULL); + + Transform get_next_snapped_prop_transform(Spatial *s, Transform parent_transform, bool snap_to_mesh, Vector3 snap_axis); + Transform get_next_snapped_prop_transform_bind(Node *spatial, Transform parent_transform, bool snap_to_mesh, Vector3 snap_axis); + + PropData(); + ~PropData(); + +protected: + static void _bind_methods(); + +private: + int _id; + bool _snap_to_mesh; + Vector3 _snap_axis; + + Vector > _props; +}; + +#endif diff --git a/props/prop_data_entity.cpp b/props/prop_data_entity.cpp new file mode 100644 index 0000000..89e47e8 --- /dev/null +++ b/props/prop_data_entity.cpp @@ -0,0 +1,54 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_data_entity.h" + +int PropDataEntity::get_entity_data_id() const { + return _entity_data_id; +} +void PropDataEntity::set_entity_data_id(const int value) { + _entity_data_id = value; +} + +int PropDataEntity::get_level() const { + return _level; +} +void PropDataEntity::set_level(const int value) { + _level = value; +} + +PropDataEntity::PropDataEntity() { + _entity_data_id = 0; + _level = 1; +} +PropDataEntity::~PropDataEntity() { +} + +void PropDataEntity::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_entity_data_id"), &PropDataEntity::get_entity_data_id); + ClassDB::bind_method(D_METHOD("set_entity_data_id", "value"), &PropDataEntity::set_entity_data_id); + ADD_PROPERTY(PropertyInfo(Variant::INT, "entity_data_id"), "set_entity_data_id", "get_entity_data_id"); + + ClassDB::bind_method(D_METHOD("get_level"), &PropDataEntity::get_level); + ClassDB::bind_method(D_METHOD("set_level", "value"), &PropDataEntity::set_level); + ADD_PROPERTY(PropertyInfo(Variant::INT, "level"), "set_level", "get_level"); +} diff --git a/props/prop_data_entity.h b/props/prop_data_entity.h new file mode 100644 index 0000000..bd1531b --- /dev/null +++ b/props/prop_data_entity.h @@ -0,0 +1,49 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_DATA_ENTITY_H +#define PROP_DATA_ENTITY_H + +#include "prop_data_entry.h" + +class PropDataEntity : public PropDataEntry { + GDCLASS(PropDataEntity, PropDataEntry); + +public: + int get_entity_data_id() const; + void set_entity_data_id(const int value); + + int get_level() const; + void set_level(const int value); + + PropDataEntity(); + ~PropDataEntity(); + +protected: + static void _bind_methods(); + +private: + int _level; + int _entity_data_id; +}; + +#endif diff --git a/props/prop_data_entry.cpp b/props/prop_data_entry.cpp new file mode 100644 index 0000000..4330e35 --- /dev/null +++ b/props/prop_data_entry.cpp @@ -0,0 +1,41 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_data_entry.h" + +Transform PropDataEntry::get_transform() const { + return _transform; +} +void PropDataEntry::set_transform(const Transform value) { + _transform = value; +} + +PropDataEntry::PropDataEntry() { +} +PropDataEntry::~PropDataEntry() { +} + +void PropDataEntry::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_transform"), &PropDataEntry::get_transform); + ClassDB::bind_method(D_METHOD("set_transform", "value"), &PropDataEntry::set_transform); + ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM, "transform"), "set_transform", "get_transform"); +} diff --git a/props/prop_data_entry.h b/props/prop_data_entry.h new file mode 100644 index 0000000..0657162 --- /dev/null +++ b/props/prop_data_entry.h @@ -0,0 +1,46 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_DATA_DATA_H +#define PROP_DATA_DATA_H + +#include "core/math/transform.h" +#include "core/resource.h" + +class PropDataEntry : public Resource { + GDCLASS(PropDataEntry, Resource); + +public: + Transform get_transform() const; + void set_transform(const Transform value); + + PropDataEntry(); + ~PropDataEntry(); + +protected: + static void _bind_methods(); + +private: + Transform _transform; +}; + +#endif diff --git a/props/prop_data_light.cpp b/props/prop_data_light.cpp new file mode 100644 index 0000000..3e7e466 --- /dev/null +++ b/props/prop_data_light.cpp @@ -0,0 +1,53 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_data_light.h" + +Color PropDataLight::get_light_color() const { + return _light_color; +} +void PropDataLight::set_light_color(const Color value) { + _light_color = value; +} + +int PropDataLight::get_light_size() const { + return _light_size; +} +void PropDataLight::set_light_size(const int value) { + _light_size = value; +} + +PropDataLight::PropDataLight() { + _light_size = 5; +} +PropDataLight::~PropDataLight() { +} + +void PropDataLight::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_light_color"), &PropDataLight::get_light_color); + ClassDB::bind_method(D_METHOD("set_light_color", "value"), &PropDataLight::set_light_color); + ADD_PROPERTY(PropertyInfo(Variant::COLOR, "light_color"), "set_light_color", "get_light_color"); + + ClassDB::bind_method(D_METHOD("get_light_size"), &PropDataLight::get_light_size); + ClassDB::bind_method(D_METHOD("set_light_size", "value"), &PropDataLight::set_light_size); + ADD_PROPERTY(PropertyInfo(Variant::INT, "light_size"), "set_light_size", "get_light_size"); +} diff --git a/props/prop_data_light.h b/props/prop_data_light.h new file mode 100644 index 0000000..db9349b --- /dev/null +++ b/props/prop_data_light.h @@ -0,0 +1,51 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_DATA_LIGHT_H +#define PROP_DATA_LIGHT_H + +#include "prop_data_entry.h" + +#include "core/color.h" + +class PropDataLight : public PropDataEntry { + GDCLASS(PropDataLight, PropDataEntry); + +public: + Color get_light_color() const; + void set_light_color(const Color value); + + int get_light_size() const; + void set_light_size(const int value); + + PropDataLight(); + ~PropDataLight(); + +protected: + static void _bind_methods(); + +private: + Color _light_color; + int _light_size; +}; + +#endif diff --git a/props/prop_data_mesh.cpp b/props/prop_data_mesh.cpp new file mode 100644 index 0000000..f5471aa --- /dev/null +++ b/props/prop_data_mesh.cpp @@ -0,0 +1,78 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_data_mesh.h" + +Ref PropDataMesh::get_mesh() const { + return _mesh; +} +void PropDataMesh::set_mesh(const Ref mesh) { + _mesh = mesh; +} + +Ref PropDataMesh::get_texture() const { + return _texture; +} +void PropDataMesh::set_texture(const Ref texture) { + _texture = texture; +} + +bool PropDataMesh::get_snap_to_mesh() { + return _snap_to_mesh; +} +void PropDataMesh::set_snap_to_mesh(bool value) { + _snap_to_mesh = value; +} + +Vector3 PropDataMesh::get_snap_axis() { + return _snap_axis; +} +void PropDataMesh::set_snap_axis(Vector3 value) { + _snap_axis = value; +} + +PropDataMesh::PropDataMesh() { + _snap_to_mesh = true; + _snap_axis = Vector3(0, 1, 0); +} +PropDataMesh::~PropDataMesh() { + if (_mesh.is_valid()) + _mesh.unref(); +} + +void PropDataMesh::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_mesh"), &PropDataMesh::get_mesh); + ClassDB::bind_method(D_METHOD("set_mesh", "value"), &PropDataMesh::set_mesh); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "mesh", PROPERTY_HINT_RESOURCE_TYPE, "MeshDataResource"), "set_mesh", "get_mesh"); + + ClassDB::bind_method(D_METHOD("get_texture"), &PropDataMesh::get_texture); + ClassDB::bind_method(D_METHOD("set_texture", "value"), &PropDataMesh::set_texture); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture"); + + ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropDataMesh::get_snap_to_mesh); + ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropDataMesh::set_snap_to_mesh); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_snap_to_mesh"); + + ClassDB::bind_method(D_METHOD("get_snap_axis"), &PropDataMesh::get_snap_axis); + ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropDataMesh::set_snap_axis); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis"); +} diff --git a/props/prop_data_mesh.h b/props/prop_data_mesh.h new file mode 100644 index 0000000..314f57a --- /dev/null +++ b/props/prop_data_mesh.h @@ -0,0 +1,62 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_DATA_MESH_H +#define PROP_DATA_MESH_H + +#include "core/math/vector3.h" +#include "prop_data_entry.h" + +#include "scene/resources/texture.h" + +#include "../../mesh_data_resource/mesh_data_resource.h" + +class PropDataMesh : public PropDataEntry { + GDCLASS(PropDataMesh, PropDataEntry); + +public: + Ref get_mesh() const; + void set_mesh(const Ref mesh); + + Ref get_texture() const; + void set_texture(const Ref texture); + + bool get_snap_to_mesh(); + void set_snap_to_mesh(bool value); + + Vector3 get_snap_axis(); + void set_snap_axis(Vector3 value); + + PropDataMesh(); + ~PropDataMesh(); + +protected: + static void _bind_methods(); + +private: + bool _snap_to_mesh; + Vector3 _snap_axis; + Ref _mesh; + Ref _texture; +}; + +#endif diff --git a/props/prop_data_prop.cpp b/props/prop_data_prop.cpp new file mode 100644 index 0000000..21e8cc0 --- /dev/null +++ b/props/prop_data_prop.cpp @@ -0,0 +1,67 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_data_prop.h" + +Ref PropDataProp::get_prop() const { + return _prop; +} +void PropDataProp::set_prop(const Ref value) { + _prop = value; +} + +bool PropDataProp::get_snap_to_mesh() { + return _snap_to_mesh; +} +void PropDataProp::set_snap_to_mesh(bool value) { + _snap_to_mesh = value; +} + +Vector3 PropDataProp::get_snap_axis() { + return _snap_axis; +} +void PropDataProp::set_snap_axis(Vector3 value) { + _snap_axis = value; +} + +PropDataProp::PropDataProp() { + _snap_to_mesh = false; + _snap_axis = Vector3(0, 1, 0); +} +PropDataProp::~PropDataProp() { + if (_prop.is_valid()) + _prop.unref(); +} + +void PropDataProp::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_prop"), &PropDataProp::get_prop); + ClassDB::bind_method(D_METHOD("set_prop", "value"), &PropDataProp::set_prop); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "prop", PROPERTY_HINT_RESOURCE_TYPE, "PropData"), "set_prop", "get_prop"); + + ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropDataProp::get_snap_to_mesh); + ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropDataProp::set_snap_to_mesh); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_snap_to_mesh"); + + ClassDB::bind_method(D_METHOD("get_snap_axis"), &PropDataProp::get_snap_axis); + ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropDataProp::set_snap_axis); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis"); +} diff --git a/props/prop_data_prop.h b/props/prop_data_prop.h new file mode 100644 index 0000000..8c14f92 --- /dev/null +++ b/props/prop_data_prop.h @@ -0,0 +1,56 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_DATA_PROP_H +#define PROP_DATA_PROP_H + +#include "core/math/vector3.h" +#include "prop_data_entry.h" + +#include "prop_data.h" + +class PropDataProp : public PropDataEntry { + GDCLASS(PropDataProp, PropDataEntry); + +public: + Ref get_prop() const; + void set_prop(const Ref value); + + bool get_snap_to_mesh(); + void set_snap_to_mesh(bool value); + + Vector3 get_snap_axis(); + void set_snap_axis(Vector3 value); + + PropDataProp(); + ~PropDataProp(); + +protected: + static void _bind_methods(); + +private: + bool _snap_to_mesh; + Vector3 _snap_axis; + Ref _prop; +}; + +#endif diff --git a/props/prop_data_scene.cpp b/props/prop_data_scene.cpp new file mode 100644 index 0000000..80d35d7 --- /dev/null +++ b/props/prop_data_scene.cpp @@ -0,0 +1,67 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "prop_data_scene.h" + +Ref PropDataScene::get_scene() const { + return _scene; +} +void PropDataScene::set_scene(const Ref value) { + _scene = value; +} + +bool PropDataScene::get_snap_to_mesh() { + return _snap_to_mesh; +} +void PropDataScene::set_snap_to_mesh(bool value) { + _snap_to_mesh = value; +} + +Vector3 PropDataScene::get_snap_axis() { + return _snap_axis; +} +void PropDataScene::set_snap_axis(Vector3 value) { + _snap_axis = value; +} + +PropDataScene::PropDataScene() { + _snap_to_mesh = true; + _snap_axis = Vector3(0, 1, 0); +} +PropDataScene::~PropDataScene() { + if (_scene.is_valid()) + _scene.unref(); +} + +void PropDataScene::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_scene"), &PropDataScene::get_scene); + ClassDB::bind_method(D_METHOD("set_scene", "value"), &PropDataScene::set_scene); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "scene", PROPERTY_HINT_RESOURCE_TYPE, "PackedScene"), "set_scene", "get_scene"); + + ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropDataScene::get_snap_to_mesh); + ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropDataScene::set_snap_to_mesh); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_snap_to_mesh"); + + ClassDB::bind_method(D_METHOD("get_snap_axis"), &PropDataScene::get_snap_axis); + ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropDataScene::set_snap_axis); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis"); +} diff --git a/props/prop_data_scene.h b/props/prop_data_scene.h new file mode 100644 index 0000000..c9c4e62 --- /dev/null +++ b/props/prop_data_scene.h @@ -0,0 +1,56 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROP_DATA_SCENE_H +#define PROP_DATA_SCENE_H + +#include "core/math/vector3.h" +#include "prop_data_entry.h" + +#include "scene/resources/packed_scene.h" + +class PropDataScene : public PropDataEntry { + GDCLASS(PropDataScene, PropDataEntry); + +public: + Ref get_scene() const; + void set_scene(const Ref value); + + bool get_snap_to_mesh(); + void set_snap_to_mesh(bool value); + + Vector3 get_snap_axis(); + void set_snap_axis(Vector3 value); + + PropDataScene(); + ~PropDataScene(); + +protected: + static void _bind_methods(); + +private: + bool _snap_to_mesh; + Vector3 _snap_axis; + Ref _scene; +}; + +#endif diff --git a/register_types.cpp b/register_types.cpp new file mode 100644 index 0000000..2b964d1 --- /dev/null +++ b/register_types.cpp @@ -0,0 +1,71 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "register_types.h" + +#include "props/prop_data.h" +#include "props/prop_data_entity.h" +#include "props/prop_data_entry.h" +#include "props/prop_data_light.h" +#include "props/prop_data_mesh.h" +#include "props/prop_data_prop.h" +#include "props/prop_data_scene.h" + +#include "clutter/ground_clutter.h" +#include "clutter/ground_clutter_foliage.h" + +#include "prop_tool/prop_tool.h" +#include "prop_tool/prop_tool_entity.h" +#include "prop_tool/prop_tool_light.h" +#include "prop_tool/prop_tool_mesh.h" +#include "prop_tool/prop_tool_prop.h" +#include "prop_tool/prop_tool_scene.h" + +#ifdef TOOLS_ENABLED +#include "prop_tool/prop_tool_editor_plugin.h" +#endif + +void register_props_types() { + ClassDB::register_class(); + ClassDB::register_class(); + ClassDB::register_class(); + ClassDB::register_class(); + ClassDB::register_class(); + ClassDB::register_class(); + ClassDB::register_class(); + + ClassDB::register_class(); + + ClassDB::register_class(); + ClassDB::register_class(); + ClassDB::register_class(); + ClassDB::register_class(); + ClassDB::register_class(); + ClassDB::register_class(); + +#ifdef TOOLS_ENABLED + EditorPlugins::add_by_type(); +#endif +} + +void unregister_props_types() { +} diff --git a/register_types.h b/register_types.h new file mode 100644 index 0000000..61c7a6a --- /dev/null +++ b/register_types.h @@ -0,0 +1,29 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef PROPS_REGISTER_TYPES_H +#define PROPS_REGISTER_TYPES_H + +void register_props_types(); +void unregister_props_types(); + +#endif