Relintai/props_2d
1
0
Fork 0
mirror of https://github.com/Relintai/props_2d.git synced 2025-02-04 16:15:57 +01:00
Code Issues Packages Projects Releases Wiki Activity

Postfix every class with 2D.

Browse Source
This commit is contained in:
Relintai 2021-11-24 14:00:16 +01:00
parent ee35479d38
commit 6f802fcf68
54 changed files with 1452 additions and 1452 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
clutter/ground_clutter_2d.cpp
View File

@ -25,45 +25,45 @@ SOFTWARE.
#ifdef VOXELMAN_PRESENT #ifdef VOXELMAN_PRESENT
#include "../../voxelman/world/voxel_chunk.h" #include "../../voxelman/world/voxel_chunk.h"
bool GroundClutter::should_spawn(Ref<VoxelChunk> chunk, int x, int y, int z) { bool GroundClutter2D::should_spawn(Ref<VoxelChunk> chunk, int x, int y, int z) {
if (has_method("_should_spawn")) if (has_method("_should_spawn"))
return call("_should_spawn", chunk, x, y, z); return call("_should_spawn", chunk, x, y, z);
return false; return false;
} }
void GroundClutter::add_meshes_to(Ref<VoxelMesher> mesher, Ref<VoxelChunk> chunk, int x, int y, int z) { void GroundClutter2D::add_meshes_to(Ref<VoxelMesher> mesher, Ref<VoxelChunk> chunk, int x, int y, int z) {
if (has_method("_add_meshes_to")) if (has_method("_add_meshes_to"))
call("_add_meshes_to", mesher, chunk, x, y, z); call("_add_meshes_to", mesher, chunk, x, y, z);
} }
#endif #endif
#ifdef TEXTURE_PACKER_PRESENT #ifdef TEXTURE_PACKER_PRESENT
void GroundClutter::add_textures_to(Ref<TexturePacker> packer) { void GroundClutter2D::add_textures_to(Ref<TexturePacker> packer) {
if (has_method("_add_textures_to")) if (has_method("_add_textures_to"))
call("_add_textures_to", packer); call("_add_textures_to", packer);
} }
#endif #endif
GroundClutter::GroundClutter() { GroundClutter2D::GroundClutter2D() {
} }
GroundClutter::~GroundClutter() { GroundClutter2D::~GroundClutter2D() {
} }
void GroundClutter::_bind_methods() { void GroundClutter2D::_bind_methods() {
#ifdef TEXTURE_PACKER_PRESENT #ifdef TEXTURE_PACKER_PRESENT
BIND_VMETHOD(MethodInfo("_add_textures_to", PropertyInfo(Variant::OBJECT, "packer", PROPERTY_HINT_RESOURCE_TYPE, "TexturePacker"))); BIND_VMETHOD(MethodInfo("_add_textures_to", PropertyInfo(Variant::OBJECT, "packer", PROPERTY_HINT_RESOURCE_TYPE, "TexturePacker")));
ClassDB::bind_method(D_METHOD("add_textures_to", "packer"), &GroundClutter::add_textures_to); ClassDB::bind_method(D_METHOD("add_textures_to", "packer"), &GroundClutter2D::add_textures_to);
#endif #endif
#ifdef VOXELMAN_PRESENT #ifdef VOXELMAN_PRESENT
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(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_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")));
ClassDB::bind_method(D_METHOD("should_spawn", "chunk", "x", "y", "z"), &GroundClutter::should_spawn); ClassDB::bind_method(D_METHOD("should_spawn", "chunk", "x", "y", "z"), &GroundClutter2D::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_meshes_to", "mesher", "chunk", "x", "y", "z"), &GroundClutter2D::add_meshes_to);
#endif #endif
} }

8
clutter/ground_clutter_2d.h
View File

@ -42,8 +42,8 @@ SOFTWARE.
class VoxelChunk; class VoxelChunk;
class VoxelMesher; class VoxelMesher;
class GroundClutter : public Resource { class GroundClutter2D : public Resource {
GDCLASS(GroundClutter, Resource); GDCLASS(GroundClutter2D, Resource);
public: public:
#ifdef VOXELMAN_PRESENT #ifdef VOXELMAN_PRESENT
@ -56,8 +56,8 @@ public:
void add_textures_to(Ref<TexturePacker> packer); void add_textures_to(Ref<TexturePacker> packer);
#endif #endif
GroundClutter(); GroundClutter2D();
~GroundClutter(); ~GroundClutter2D();
private: private:
static void _bind_methods(); static void _bind_methods();

22
clutter/ground_clutter_foliage_2d.cpp
View File

@ -22,33 +22,33 @@ SOFTWARE.
#include "ground_clutter_foliage_2d.h" #include "ground_clutter_foliage_2d.h"
int GroundClutterFoliage::get_texture_count() const { int GroundClutterFoliage2D::get_texture_count() const {
return _textures.size(); return _textures.size();
} }
Ref<Texture> GroundClutterFoliage::get_texture(const int index) { Ref<Texture> GroundClutterFoliage2D::get_texture(const int index) {
ERR_FAIL_INDEX_V(index, _textures.size(), Ref<Texture>()); ERR_FAIL_INDEX_V(index, _textures.size(), Ref<Texture>());
return _textures.get(index); return _textures.get(index);
} }
void GroundClutterFoliage::remove_texture(const int index) { void GroundClutterFoliage2D::remove_texture(const int index) {
ERR_FAIL_INDEX(index, _textures.size()); ERR_FAIL_INDEX(index, _textures.size());
_textures.remove(index); _textures.remove(index);
} }
void GroundClutterFoliage::add_texture(Ref<Texture> texture) { void GroundClutterFoliage2D::add_texture(Ref<Texture> texture) {
_textures.push_back(texture); _textures.push_back(texture);
} }
GroundClutterFoliage::GroundClutterFoliage() { GroundClutterFoliage2D::GroundClutterFoliage2D() {
} }
GroundClutterFoliage::~GroundClutterFoliage() { GroundClutterFoliage2D::~GroundClutterFoliage2D() {
_textures.clear(); _textures.clear();
} }
void GroundClutterFoliage::_bind_methods() { void GroundClutterFoliage2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_texture_count"), &GroundClutterFoliage::get_texture_count); ClassDB::bind_method(D_METHOD("get_texture_count"), &GroundClutterFoliage2D::get_texture_count);
ClassDB::bind_method(D_METHOD("get_texture", "index"), &GroundClutterFoliage::get_texture); ClassDB::bind_method(D_METHOD("get_texture", "index"), &GroundClutterFoliage2D::get_texture);
ClassDB::bind_method(D_METHOD("remove_texture", "index"), &GroundClutterFoliage::remove_texture); ClassDB::bind_method(D_METHOD("remove_texture", "index"), &GroundClutterFoliage2D::remove_texture);
ClassDB::bind_method(D_METHOD("add_texture", "texture"), &GroundClutterFoliage::add_texture); ClassDB::bind_method(D_METHOD("add_texture", "texture"), &GroundClutterFoliage2D::add_texture);
} }

8
clutter/ground_clutter_foliage_2d.h
View File

@ -35,8 +35,8 @@ SOFTWARE.
#include "scene/resources/texture.h" #include "scene/resources/texture.h"
class GroundClutterFoliage : public GroundClutter { class GroundClutterFoliage2D : public GroundClutter2D {
GDCLASS(GroundClutterFoliage, GroundClutter); GDCLASS(GroundClutterFoliage2D, GroundClutter2D);
public: public:
int get_texture_count() const; int get_texture_count() const;
@ -44,8 +44,8 @@ public:
void remove_texture(const int index); void remove_texture(const int index);
void add_texture(Ref<Texture> texture); void add_texture(Ref<Texture> texture);
GroundClutterFoliage(); GroundClutterFoliage2D();
~GroundClutterFoliage(); ~GroundClutterFoliage2D();
private: private:
static void _bind_methods(); static void _bind_methods();

34
config.py
View File

@ -10,29 +10,29 @@ def configure(env):
def get_doc_classes(): def get_doc_classes():
return [ return [
"PropDataEntry", "PropDataEntry2D",
"PropDataLight", "PropDataLight2D",
"PropDataProp", "PropDataProp2D",
"PropDataScene", "PropDataScene2D",
"PropDataPortal", "PropDataPortal2D",
"PropDataTiledWall", "PropDataTiledWall2D",
"PropData", "PropData2D",
"TiledWall", "TiledWall2D",
"TiledWallData", "TiledWallData2D",
"PropDataProcessor", "PropDataProcessor2D",
"GroundClutterFoliage", "GroundClutterFoliage2D",
"GroundClutter", "GroundClutter2D",
"PropESSEntity", "PropESSEntity2D",
"PropInstance", "PropInstance2D",
"PropMeshUtils", "PropMeshUtils2D",
"PropSceneInstance", "PropSceneInstance2D",
"PropUtils", "PropUtils2D",
] ]
def get_doc_path(): def get_doc_path():

36
editor/prop_editor_plugin_2d.cpp
View File

@ -41,7 +41,7 @@ SOFTWARE.
#define DISCONNECT(sig, obj, target_method_class, method) disconnect(sig, callable_mp(obj, &target_method_class::method)) #define DISCONNECT(sig, obj, target_method_class, method) disconnect(sig, callable_mp(obj, &target_method_class::method))
#endif #endif
void PropEditorPlugin::convert_active_scene_to_prop_data() { void PropEditorPlugin2D::convert_active_scene_to_prop_data() {
SceneTree *st = SceneTree::get_singleton(); SceneTree *st = SceneTree::get_singleton();
if (st) { if (st) {
@ -55,17 +55,17 @@ void PropEditorPlugin::convert_active_scene_to_prop_data() {
} }
} }
} }
void PropEditorPlugin::convert_selected_scene_to_prop_data() { void PropEditorPlugin2D::convert_selected_scene_to_prop_data() {
} }
void PropEditorPlugin::convert_scene(Node *root, const String &path) { void PropEditorPlugin2D::convert_scene(Node *root, const String &path) {
Ref<PropData> data = PropUtils::get_singleton()->convert_tree(root); Ref<PropData2D> data = PropUtils2D::get_singleton()->convert_tree(root);
ERR_FAIL_COND(!data.is_valid()); ERR_FAIL_COND(!data.is_valid());
ResourceLoader l; ResourceLoader l;
if (l.exists(path)) { if (l.exists(path)) {
Ref<PropData> res = l.load(path, "PropData"); Ref<PropData2D> res = l.load(path, "PropData");
ERR_FAIL_COND(!res.is_valid()); ERR_FAIL_COND(!res.is_valid());
@ -81,7 +81,7 @@ void PropEditorPlugin::convert_scene(Node *root, const String &path) {
} }
} }
void PropEditorPlugin::find_room_points(Variant param) { void PropEditorPlugin2D::find_room_points(Variant param) {
#if VERSION_MINOR >= 4 #if VERSION_MINOR >= 4
SceneTree *st = SceneTree::get_singleton(); SceneTree *st = SceneTree::get_singleton();
@ -89,24 +89,24 @@ void PropEditorPlugin::find_room_points(Variant param) {
Node *scene = st->get_edited_scene_root(); Node *scene = st->get_edited_scene_root();
if (scene) { if (scene) {
PropUtils::get_singleton()->generate_room_points_node(scene); PropUtils2D::get_singleton()->generate_room_points_node(scene);
} }
} }
#endif #endif
} }
void PropEditorPlugin::_quick_convert_button_pressed() { void PropEditorPlugin2D::_quick_convert_button_pressed() {
convert_active_scene_to_prop_data(); convert_active_scene_to_prop_data();
} }
void PropEditorPlugin::_convert_active_scene_to_prop_data(Variant param) { void PropEditorPlugin2D::_convert_active_scene_to_prop_data(Variant param) {
convert_active_scene_to_prop_data(); convert_active_scene_to_prop_data();
} }
void PropEditorPlugin::_convert_selected_scene_to_prop_data(Variant param) { void PropEditorPlugin2D::_convert_selected_scene_to_prop_data(Variant param) {
convert_selected_scene_to_prop_data(); convert_selected_scene_to_prop_data();
} }
PropEditorPlugin::PropEditorPlugin(EditorNode *p_node) { PropEditorPlugin2D::PropEditorPlugin2D(EditorNode *p_node) {
editor = p_node; editor = p_node;
#if VERSION_MAJOR < 4 #if VERSION_MAJOR < 4
@ -126,21 +126,21 @@ PropEditorPlugin::PropEditorPlugin(EditorNode *p_node) {
container->add_child(b); container->add_child(b);
b->set_flat(true); b->set_flat(true);
b->CONNECT("pressed", this, PropEditorPlugin, _quick_convert_button_pressed); b->CONNECT("pressed", this, PropEditorPlugin2D, _quick_convert_button_pressed);
b->set_text("To Prop"); b->set_text("To Prop");
b->set_shortcut(ED_SHORTCUT("spatial_editor/quick_prop_convert", "Quick convert scene to PropData.", KEY_MASK_ALT + KEY_U)); b->set_shortcut(ED_SHORTCUT("spatial_editor/quick_prop_convert", "Quick convert scene to PropData.", KEY_MASK_ALT + KEY_U));
add_control_to_container(EditorPlugin::CONTAINER_SPATIAL_EDITOR_MENU, container); add_control_to_container(EditorPlugin::CONTAINER_SPATIAL_EDITOR_MENU, container);
} }
PropEditorPlugin::~PropEditorPlugin() { PropEditorPlugin2D::~PropEditorPlugin2D() {
} }
void PropEditorPlugin::_bind_methods() { void PropEditorPlugin2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("convert_active_scene_to_prop_data"), &PropEditorPlugin::_convert_active_scene_to_prop_data); ClassDB::bind_method(D_METHOD("convert_active_scene_to_prop_data"), &PropEditorPlugin2D::_convert_active_scene_to_prop_data);
ClassDB::bind_method(D_METHOD("convert_selected_scene_to_prop_data"), &PropEditorPlugin::_convert_active_scene_to_prop_data); ClassDB::bind_method(D_METHOD("convert_selected_scene_to_prop_data"), &PropEditorPlugin2D::_convert_active_scene_to_prop_data);
ClassDB::bind_method(D_METHOD("find_room_points"), &PropEditorPlugin::find_room_points); ClassDB::bind_method(D_METHOD("find_room_points"), &PropEditorPlugin2D::find_room_points);
ClassDB::bind_method(D_METHOD("_quick_convert_button_pressed"), &PropEditorPlugin::_quick_convert_button_pressed); ClassDB::bind_method(D_METHOD("_quick_convert_button_pressed"), &PropEditorPlugin2D::_quick_convert_button_pressed);
} }

10
editor/prop_editor_plugin_2d.h
View File

@ -28,16 +28,16 @@ SOFTWARE.
#include "core/version.h" #include "core/version.h"
class PropEditorPlugin : public EditorPlugin { class PropEditorPlugin2D : public EditorPlugin {
GDCLASS(PropEditorPlugin, EditorPlugin); GDCLASS(PropEditorPlugin2D, EditorPlugin);
EditorNode *editor; EditorNode *editor;
protected: protected:
static void _bind_methods(); static void _bind_methods();
public: public:
virtual String get_name() const { return "PropEditorPlugin"; } virtual String get_name() const { return "PropEditorPlugin2D"; }
bool has_main_screen() const { return false; } bool has_main_screen() const { return false; }
virtual void edit(Object *p_object) {} virtual void edit(Object *p_object) {}
virtual bool handles(Object *p_object) const { return false; } virtual bool handles(Object *p_object) const { return false; }
@ -53,8 +53,8 @@ public:
void _convert_selected_scene_to_prop_data(Variant param); void _convert_selected_scene_to_prop_data(Variant param);
void _quick_convert_button_pressed(); void _quick_convert_button_pressed();
PropEditorPlugin(EditorNode *p_node); PropEditorPlugin2D(EditorNode *p_node);
~PropEditorPlugin(); ~PropEditorPlugin2D();
}; };
#endif #endif

58
jobs/prop_mesher_job_step_2d.cpp
View File

@ -22,54 +22,54 @@ SOFTWARE.
#include "prop_mesher_job_step_2d.h" #include "prop_mesher_job_step_2d.h"
const String PropMesherJobStep::BINDING_STRING_PROP_MESHER_JOB_STEP_TYPE = "Normal,Normal LOD,Drop UV2,Merge Verts,Bake Texture,Simplify Mesh"; const String PropMesherJobStep2D::BINDING_STRING_PROP_MESHER_JOB_STEP_TYPE = "Normal,Normal LOD,Drop UV2,Merge Verts,Bake Texture,Simplify Mesh";
PropMesherJobStep::PropMesherJobStepType PropMesherJobStep::get_job_type() const { PropMesherJobStep2D::PropMesherJobStepType2D PropMesherJobStep2D::get_job_type() const {
return _job_type; return _job_type;
} }
void PropMesherJobStep::set_job_type(const PropMesherJobStep::PropMesherJobStepType value) { void PropMesherJobStep2D::set_job_type(const PropMesherJobStep2D::PropMesherJobStepType2D value) {
_job_type = value; _job_type = value;
} }
int PropMesherJobStep::get_lod_index() const { int PropMesherJobStep2D::get_lod_index() const {
return _lod_index; return _lod_index;
} }
void PropMesherJobStep::set_lod_index(const int value) { void PropMesherJobStep2D::set_lod_index(const int value) {
_lod_index = value; _lod_index = value;
} }
#ifdef MESH_UTILS_PRESENT #ifdef MESH_UTILS_PRESENT
Ref<FastQuadraticMeshSimplifier> PropMesherJobStep::get_fqms() { Ref<FastQuadraticMeshSimplifier> PropMesherJobStep2D::get_fqms() {
return _fqms; return _fqms;
} }
void PropMesherJobStep::set_fqms(const Ref<FastQuadraticMeshSimplifier> &val) { void PropMesherJobStep2D::set_fqms(const Ref<FastQuadraticMeshSimplifier> &val) {
_fqms = val; _fqms = val;
} }
float PropMesherJobStep::get_simplification_step_ratio() const { float PropMesherJobStep2D::get_simplification_step_ratio() const {
return _simplification_step_ratio; return _simplification_step_ratio;
} }
void PropMesherJobStep::set_simplification_step_ratio(const float value) { void PropMesherJobStep2D::set_simplification_step_ratio(const float value) {
_simplification_step_ratio = value; _simplification_step_ratio = value;
} }
int PropMesherJobStep::get_simplification_steps() const { int PropMesherJobStep2D::get_simplification_steps() const {
return _simplification_steps; return _simplification_steps;
} }
void PropMesherJobStep::set_simplification_steps(const int value) { void PropMesherJobStep2D::set_simplification_steps(const int value) {
_simplification_steps = value; _simplification_steps = value;
} }
float PropMesherJobStep::get_simplification_agressiveness() const { float PropMesherJobStep2D::get_simplification_agressiveness() const {
return _simplification_agressiveness; return _simplification_agressiveness;
} }
void PropMesherJobStep::set_simplification_agressiveness(const float value) { void PropMesherJobStep2D::set_simplification_agressiveness(const float value) {
_simplification_agressiveness = value; _simplification_agressiveness = value;
} }
#endif #endif
PropMesherJobStep::PropMesherJobStep() { PropMesherJobStep2D::PropMesherJobStep2D() {
_job_type = TYPE_NORMAL; _job_type = TYPE_NORMAL;
_lod_index = 0; _lod_index = 0;
@ -80,36 +80,36 @@ PropMesherJobStep::PropMesherJobStep() {
#endif #endif
} }
PropMesherJobStep::~PropMesherJobStep() { PropMesherJobStep2D::~PropMesherJobStep2D() {
#ifdef MESH_UTILS_PRESENT #ifdef MESH_UTILS_PRESENT
_fqms.unref(); _fqms.unref();
#endif #endif
} }
void PropMesherJobStep::_bind_methods() { void PropMesherJobStep2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_job_type"), &PropMesherJobStep::get_job_type); ClassDB::bind_method(D_METHOD("get_job_type"), &PropMesherJobStep2D::get_job_type);
ClassDB::bind_method(D_METHOD("set_job_type", "value"), &PropMesherJobStep::set_job_type); ClassDB::bind_method(D_METHOD("set_job_type", "value"), &PropMesherJobStep2D::set_job_type);
ADD_PROPERTY(PropertyInfo(Variant::INT, "job_type", PROPERTY_HINT_ENUM, PropMesherJobStep::BINDING_STRING_PROP_MESHER_JOB_STEP_TYPE), "set_job_type", "get_job_type"); ADD_PROPERTY(PropertyInfo(Variant::INT, "job_type", PROPERTY_HINT_ENUM, PropMesherJobStep2D::BINDING_STRING_PROP_MESHER_JOB_STEP_TYPE), "set_job_type", "get_job_type");
ClassDB::bind_method(D_METHOD("get_lod_index"), &PropMesherJobStep::get_lod_index); ClassDB::bind_method(D_METHOD("get_lod_index"), &PropMesherJobStep2D::get_lod_index);
ClassDB::bind_method(D_METHOD("set_lod_index", "value"), &PropMesherJobStep::set_lod_index); ClassDB::bind_method(D_METHOD("set_lod_index", "value"), &PropMesherJobStep2D::set_lod_index);
ADD_PROPERTY(PropertyInfo(Variant::INT, "lod_index"), "set_lod_index", "get_lod_index"); ADD_PROPERTY(PropertyInfo(Variant::INT, "lod_index"), "set_lod_index", "get_lod_index");
#ifdef MESH_UTILS_PRESENT #ifdef MESH_UTILS_PRESENT
ClassDB::bind_method(D_METHOD("get_fqms"), &PropMesherJobStep::get_fqms); ClassDB::bind_method(D_METHOD("get_fqms"), &PropMesherJobStep2D::get_fqms);
ClassDB::bind_method(D_METHOD("set_fqms", "value"), &PropMesherJobStep::set_fqms); ClassDB::bind_method(D_METHOD("set_fqms", "value"), &PropMesherJobStep2D::set_fqms);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "fqms", PROPERTY_HINT_RESOURCE_TYPE, "FastQuadraticMeshSimplifier"), "set_fqms", "get_fqms"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "fqms", PROPERTY_HINT_RESOURCE_TYPE, "FastQuadraticMeshSimplifier"), "set_fqms", "get_fqms");
ClassDB::bind_method(D_METHOD("get_simplification_step_ratio"), &PropMesherJobStep::get_simplification_step_ratio); ClassDB::bind_method(D_METHOD("get_simplification_step_ratio"), &PropMesherJobStep2D::get_simplification_step_ratio);
ClassDB::bind_method(D_METHOD("set_simplification_step_ratio", "value"), &PropMesherJobStep::set_simplification_step_ratio); ClassDB::bind_method(D_METHOD("set_simplification_step_ratio", "value"), &PropMesherJobStep2D::set_simplification_step_ratio);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "simplification_step_ratio"), "set_simplification_step_ratio", "get_simplification_step_ratio"); ADD_PROPERTY(PropertyInfo(Variant::REAL, "simplification_step_ratio"), "set_simplification_step_ratio", "get_simplification_step_ratio");
ClassDB::bind_method(D_METHOD("get_simplification_steps"), &PropMesherJobStep::get_simplification_steps); ClassDB::bind_method(D_METHOD("get_simplification_steps"), &PropMesherJobStep2D::get_simplification_steps);
ClassDB::bind_method(D_METHOD("set_simplification_steps", "value"), &PropMesherJobStep::set_simplification_steps); ClassDB::bind_method(D_METHOD("set_simplification_steps", "value"), &PropMesherJobStep2D::set_simplification_steps);
ADD_PROPERTY(PropertyInfo(Variant::INT, "simplification_steps"), "set_simplification_steps", "get_simplification_steps"); ADD_PROPERTY(PropertyInfo(Variant::INT, "simplification_steps"), "set_simplification_steps", "get_simplification_steps");
ClassDB::bind_method(D_METHOD("get_simplification_agressiveness"), &PropMesherJobStep::get_simplification_agressiveness); ClassDB::bind_method(D_METHOD("get_simplification_agressiveness"), &PropMesherJobStep2D::get_simplification_agressiveness);
ClassDB::bind_method(D_METHOD("set_simplification_agressiveness", "value"), &PropMesherJobStep::set_simplification_agressiveness); ClassDB::bind_method(D_METHOD("set_simplification_agressiveness", "value"), &PropMesherJobStep2D::set_simplification_agressiveness);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "simplification_agressiveness"), "set_simplification_agressiveness", "get_simplification_agressiveness"); ADD_PROPERTY(PropertyInfo(Variant::REAL, "simplification_agressiveness"), "set_simplification_agressiveness", "get_simplification_agressiveness");
#endif #endif

18
jobs/prop_mesher_job_step_2d.h
View File

@ -35,15 +35,15 @@ SOFTWARE.
#include "../../mesh_utils/fast_quadratic_mesh_simplifier.h" #include "../../mesh_utils/fast_quadratic_mesh_simplifier.h"
#endif #endif
class PropMesherJobStep : public Reference { class PropMesherJobStep2D : public Reference {
GDCLASS(PropMesherJobStep, Reference); GDCLASS(PropMesherJobStep2D, Reference);
public: public:
//todo add: //todo add:
//type generate lighting, //type generate lighting,
//type skip (this would leave the mesh empty) //type skip (this would leave the mesh empty)
//type previous mesh (this would set the previous mesh's rid to the current lod level) //type previous mesh (this would set the previous mesh's rid to the current lod level)
enum PropMesherJobStepType { enum PropMesherJobStepType2D {
TYPE_NORMAL = 0, TYPE_NORMAL = 0,
TYPE_NORMAL_LOD, TYPE_NORMAL_LOD,
TYPE_DROP_UV2, TYPE_DROP_UV2,
@ -55,8 +55,8 @@ public:
static const String BINDING_STRING_PROP_MESHER_JOB_STEP_TYPE; static const String BINDING_STRING_PROP_MESHER_JOB_STEP_TYPE;
PropMesherJobStepType get_job_type() const; PropMesherJobStepType2D get_job_type() const;
void set_job_type(const PropMesherJobStepType value); void set_job_type(const PropMesherJobStepType2D value);
int get_lod_index() const; int get_lod_index() const;
void set_lod_index(const int value); void set_lod_index(const int value);
@ -75,13 +75,13 @@ public:
void set_simplification_agressiveness(const float value); void set_simplification_agressiveness(const float value);
#endif #endif
PropMesherJobStep(); PropMesherJobStep2D();
~PropMesherJobStep(); ~PropMesherJobStep2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();
PropMesherJobStepType _job_type; PropMesherJobStepType2D _job_type;
int _lod_index; int _lod_index;
#ifdef MESH_UTILS_PRESENT #ifdef MESH_UTILS_PRESENT
@ -92,6 +92,6 @@ protected:
#endif #endif
}; };
VARIANT_ENUM_CAST(PropMesherJobStep::PropMesherJobStepType); VARIANT_ENUM_CAST(PropMesherJobStep2D::PropMesherJobStepType2D);
#endif #endif

76
jobs/prop_texture_job_2d.cpp
View File

@ -27,16 +27,16 @@ SOFTWARE.
#endif #endif
#if TEXTURE_PACKER_PRESENT #if TEXTURE_PACKER_PRESENT
Ref<TexturePacker> PropTextureJob::get_merger() { Ref<TexturePacker> PropTextureJob2D::get_merger() {
return _merger; return _merger;
} }
void PropTextureJob::set_merger(const Ref<TexturePacker> &merger) { void PropTextureJob2D::set_merger(const Ref<TexturePacker> &merger) {
_merger = merger; _merger = merger;
} }
#endif #endif
void PropTextureJob::_execute() { void PropTextureJob2D::_execute() {
#if TEXTURE_PACKER_PRESENT #if TEXTURE_PACKER_PRESENT
if (!_merger.is_valid()) { if (!_merger.is_valid()) {
set_complete(true); set_complete(true);
@ -49,7 +49,7 @@ void PropTextureJob::_execute() {
set_complete(true); set_complete(true);
} }
PropTextureJob::PropTextureJob() { PropTextureJob2D::PropTextureJob2D() {
#if !THREAD_POOL_PRESENT #if !THREAD_POOL_PRESENT
_complete = true; _complete = true;
_cancelled = false; _cancelled = false;
@ -62,110 +62,110 @@ PropTextureJob::PropTextureJob() {
#endif #endif
} }
PropTextureJob::~PropTextureJob() { PropTextureJob2D::~PropTextureJob2D() {
} }
void PropTextureJob::_bind_methods() { void PropTextureJob2D::_bind_methods() {
#if TEXTURE_PACKER_PRESENT #if TEXTURE_PACKER_PRESENT
ClassDB::bind_method(D_METHOD("get_merger"), &PropTextureJob::get_merger); ClassDB::bind_method(D_METHOD("get_merger"), &PropTextureJob2D::get_merger);
ClassDB::bind_method(D_METHOD("set_merger", "value"), &PropTextureJob::set_merger); ClassDB::bind_method(D_METHOD("set_merger", "value"), &PropTextureJob2D::set_merger);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "merger", PROPERTY_HINT_RESOURCE_TYPE, "TexturePacker"), "set_merger", "get_merger"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "merger", PROPERTY_HINT_RESOURCE_TYPE, "TexturePacker"), "set_merger", "get_merger");
#endif #endif
ClassDB::bind_method(D_METHOD("_execute"), &PropTextureJob::_execute); ClassDB::bind_method(D_METHOD("_execute"), &PropTextureJob2D::_execute);
#if !THREAD_POOL_PRESENT #if !THREAD_POOL_PRESENT
ClassDB::bind_method(D_METHOD("get_complete"), &PropTextureJob::get_complete); ClassDB::bind_method(D_METHOD("get_complete"), &PropTextureJob2D::get_complete);
ClassDB::bind_method(D_METHOD("set_complete", "value"), &PropTextureJob::set_complete); ClassDB::bind_method(D_METHOD("set_complete", "value"), &PropTextureJob2D::set_complete);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "complete"), "set_complete", "get_complete"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "complete"), "set_complete", "get_complete");
ClassDB::bind_method(D_METHOD("get_start_time"), &PropTextureJob::get_start_time); ClassDB::bind_method(D_METHOD("get_start_time"), &PropTextureJob2D::get_start_time);
ClassDB::bind_method(D_METHOD("set_start_time", "value"), &PropTextureJob::set_start_time); ClassDB::bind_method(D_METHOD("set_start_time", "value"), &PropTextureJob2D::set_start_time);
ADD_PROPERTY(PropertyInfo(Variant::INT, "start_time"), "set_start_time", "get_start_time"); ADD_PROPERTY(PropertyInfo(Variant::INT, "start_time"), "set_start_time", "get_start_time");
ClassDB::bind_method(D_METHOD("get_current_run_stage"), &PropTextureJob::get_current_run_stage); ClassDB::bind_method(D_METHOD("get_current_run_stage"), &PropTextureJob2D::get_current_run_stage);
ClassDB::bind_method(D_METHOD("set_current_run_stage", "value"), &PropTextureJob::set_current_run_stage); ClassDB::bind_method(D_METHOD("set_current_run_stage", "value"), &PropTextureJob2D::set_current_run_stage);
ADD_PROPERTY(PropertyInfo(Variant::INT, "current_run_stage"), "set_current_run_stage", "get_current_run_stage"); ADD_PROPERTY(PropertyInfo(Variant::INT, "current_run_stage"), "set_current_run_stage", "get_current_run_stage");
ClassDB::bind_method(D_METHOD("get_stage"), &PropTextureJob::get_stage); ClassDB::bind_method(D_METHOD("get_stage"), &PropTextureJob2D::get_stage);
ClassDB::bind_method(D_METHOD("set_stage", "value"), &PropTextureJob::set_stage); ClassDB::bind_method(D_METHOD("set_stage", "value"), &PropTextureJob2D::set_stage);
ADD_PROPERTY(PropertyInfo(Variant::INT, "stage"), "set_stage", "get_stage"); ADD_PROPERTY(PropertyInfo(Variant::INT, "stage"), "set_stage", "get_stage");
ClassDB::bind_method(D_METHOD("get_current_execution_time"), &PropTextureJob::get_current_execution_time); ClassDB::bind_method(D_METHOD("get_current_execution_time"), &PropTextureJob2D::get_current_execution_time);
ClassDB::bind_method(D_METHOD("should_do", "just_check"), &PropTextureJob::should_do, DEFVAL(false)); ClassDB::bind_method(D_METHOD("should_do", "just_check"), &PropTextureJob2D::should_do, DEFVAL(false));
ClassDB::bind_method(D_METHOD("should_return"), &PropTextureJob::should_return); ClassDB::bind_method(D_METHOD("should_return"), &PropTextureJob2D::should_return);
BIND_VMETHOD(MethodInfo("_execute")); BIND_VMETHOD(MethodInfo("_execute"));
ClassDB::bind_method(D_METHOD("execute"), &PropTextureJob::execute); ClassDB::bind_method(D_METHOD("execute"), &PropTextureJob2D::execute);
ADD_SIGNAL(MethodInfo("completed")); ADD_SIGNAL(MethodInfo("completed"));
#endif #endif
} }
#if !THREAD_POOL_PRESENT #if !THREAD_POOL_PRESENT
bool PropTextureJob::get_complete() const { bool PropTextureJob2D::get_complete() const {
return _complete; return _complete;
} }
void PropTextureJob::set_complete(const bool value) { void PropTextureJob2D::set_complete(const bool value) {
_complete = value; _complete = value;
} }
bool PropTextureJob::get_cancelled() const { bool PropTextureJob2D::get_cancelled() const {
return _cancelled; return _cancelled;
} }
void PropTextureJob::set_cancelled(const bool value) { void PropTextureJob2D::set_cancelled(const bool value) {
_cancelled = value; _cancelled = value;
} }
float PropTextureJob::get_max_allocated_time() const { float PropTextureJob2D::get_max_allocated_time() const {
return _max_allocated_time; return _max_allocated_time;
} }
void PropTextureJob::set_max_allocated_time(const float value) { void PropTextureJob2D::set_max_allocated_time(const float value) {
_max_allocated_time = value; _max_allocated_time = value;
} }
int PropTextureJob::get_start_time() const { int PropTextureJob2D::get_start_time() const {
return _start_time; return _start_time;
} }
void PropTextureJob::set_start_time(const int value) { void PropTextureJob2D::set_start_time(const int value) {
_start_time = value; _start_time = value;
} }
int PropTextureJob::get_current_run_stage() const { int PropTextureJob2D::get_current_run_stage() const {
return _current_run_stage; return _current_run_stage;
} }
void PropTextureJob::set_current_run_stage(const int value) { void PropTextureJob2D::set_current_run_stage(const int value) {
_current_run_stage = value; _current_run_stage = value;
} }
int PropTextureJob::get_stage() const { int PropTextureJob2D::get_stage() const {
return _stage; return _stage;
} }
void PropTextureJob::set_stage(const int value) { void PropTextureJob2D::set_stage(const int value) {
_stage = value; _stage = value;
} }
void PropTextureJob::reset_stages() { void PropTextureJob2D::reset_stages() {
_current_run_stage = 0; _current_run_stage = 0;
_stage = 0; _stage = 0;
} }
float PropTextureJob::get_current_execution_time() { float PropTextureJob2D::get_current_execution_time() {
return 0; return 0;
} }
bool PropTextureJob::should_do(const bool just_check) { bool PropTextureJob2D::should_do(const bool just_check) {
return true; return true;
} }
bool PropTextureJob::should_return() { bool PropTextureJob2D::should_return() {
if (_cancelled) if (_cancelled)
return true; return true;
return false; return false;
} }
void PropTextureJob::execute() { void PropTextureJob2D::execute() {
ERR_FAIL_COND(!has_method("_execute")); ERR_FAIL_COND(!has_method("_execute"));
call("_execute"); call("_execute");

12
jobs/prop_texture_job_2d.h
View File

@ -43,11 +43,11 @@ class TexturePacker;
#endif #endif
#if THREAD_POOL_PRESENT #if THREAD_POOL_PRESENT
class PropTextureJob : public ThreadPoolJob { class PropTextureJob2D : public ThreadPoolJob {
GDCLASS(PropTextureJob, ThreadPoolJob); GDCLASS(PropTextureJob2D, ThreadPoolJob);
#else #else
class PropTextureJob : public Reference { class PropTextureJob2D : public Reference {
GDCLASS(PropTextureJob, Reference); GDCLASS(PropTextureJob2D, Reference);
#endif #endif
public: public:
@ -58,8 +58,8 @@ public:
void _execute(); void _execute();
PropTextureJob(); PropTextureJob2D();
~PropTextureJob(); ~PropTextureJob2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();

30
lights/prop_light_2d.cpp
View File

@ -22,44 +22,44 @@ SOFTWARE.
#include "prop_light_2d.h" #include "prop_light_2d.h"
Vector3 PropLight::get_position() { Vector3 PropLight2D::get_position() {
return _position; return _position;
} }
void PropLight::set_position(const Vector3 &pos) { void PropLight2D::set_position(const Vector3 &pos) {
_position = pos; _position = pos;
} }
Color PropLight::get_color() const { Color PropLight2D::get_color() const {
return _color; return _color;
} }
void PropLight::set_color(const Color &color) { void PropLight2D::set_color(const Color &color) {
_color = color; _color = color;
} }
float PropLight::get_size() const { float PropLight2D::get_size() const {
return _size; return _size;
} }
void PropLight::set_size(const float size) { void PropLight2D::set_size(const float size) {
_size = size; _size = size;
} }
PropLight::PropLight() { PropLight2D::PropLight2D() {
_size = 0; _size = 0;
} }
PropLight::~PropLight() { PropLight2D::~PropLight2D() {
} }
void PropLight::_bind_methods() { void PropLight2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_position"), &PropLight::get_position); ClassDB::bind_method(D_METHOD("get_position"), &PropLight2D::get_position);
ClassDB::bind_method(D_METHOD("set_position"), &PropLight::set_position); ClassDB::bind_method(D_METHOD("set_position"), &PropLight2D::set_position);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "world_position"), "set_position", "get_position"); ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "world_position"), "set_position", "get_position");
ClassDB::bind_method(D_METHOD("get_color"), &PropLight::get_color); ClassDB::bind_method(D_METHOD("get_color"), &PropLight2D::get_color);
ClassDB::bind_method(D_METHOD("set_color"), &PropLight::set_color); ClassDB::bind_method(D_METHOD("set_color"), &PropLight2D::set_color);
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "color"), "set_color", "get_color"); ADD_PROPERTY(PropertyInfo(Variant::COLOR, "color"), "set_color", "get_color");
ClassDB::bind_method(D_METHOD("get_size"), &PropLight::get_size); ClassDB::bind_method(D_METHOD("get_size"), &PropLight2D::get_size);
ClassDB::bind_method(D_METHOD("set_size"), &PropLight::set_size); ClassDB::bind_method(D_METHOD("set_size"), &PropLight2D::set_size);
ADD_PROPERTY(PropertyInfo(Variant::INT, "size"), "set_size", "get_size"); ADD_PROPERTY(PropertyInfo(Variant::INT, "size"), "set_size", "get_size");
} }

8
lights/prop_light_2d.h
View File

@ -35,8 +35,8 @@ SOFTWARE.
#include "core/color.h" #include "core/color.h"
#endif #endif
class PropLight : public Reference { class PropLight2D : public Reference {
GDCLASS(PropLight, Reference); GDCLASS(PropLight2D, Reference);
public: public:
Vector3 get_position(); Vector3 get_position();
@ -48,8 +48,8 @@ public:
float get_size() const; float get_size() const;
void set_size(const float strength); void set_size(const float strength);
PropLight(); PropLight2D();
~PropLight(); ~PropLight2D();
private: private:
static void _bind_methods(); static void _bind_methods();

152
material_cache/prop_material_cache_2d.cpp
View File

@ -54,44 +54,44 @@ SOFTWARE.
#endif #endif
bool PropMaterialCache::get_initialized() { bool PropMaterialCache2D::get_initialized() {
return _initialized; return _initialized;
} }
void PropMaterialCache::set_initialized(const bool value) { void PropMaterialCache2D::set_initialized(const bool value) {
_initialized = value; _initialized = value;
} }
bool PropMaterialCache::mutex_locked() { bool PropMaterialCache2D::mutex_locked() {
return _locked; return _locked;
} }
void PropMaterialCache::mutex_lock() { void PropMaterialCache2D::mutex_lock() {
_mutex.lock(); _mutex.lock();
} }
void PropMaterialCache::mutex_unlock() { void PropMaterialCache2D::mutex_unlock() {
_mutex.unlock(); _mutex.unlock();
} }
int PropMaterialCache::get_ref_count() { int PropMaterialCache2D::get_ref_count() {
return _ref_count; return _ref_count;
} }
void PropMaterialCache::set_ref_count(const int value) { void PropMaterialCache2D::set_ref_count(const int value) {
_ref_count = value; _ref_count = value;
} }
void PropMaterialCache::inc_ref_count() { void PropMaterialCache2D::inc_ref_count() {
_ref_count += 1; _ref_count += 1;
} }
void PropMaterialCache::dec_ref_count() { void PropMaterialCache2D::dec_ref_count() {
_ref_count -= 1; _ref_count -= 1;
} }
//Materials //Materials
Ref<Material> PropMaterialCache::material_get(const int index) { Ref<Material> PropMaterialCache2D::material_get(const int index) {
ERR_FAIL_INDEX_V(index, _materials.size(), Ref<Material>(NULL)); ERR_FAIL_INDEX_V(index, _materials.size(), Ref<Material>(NULL));
return _materials[index]; return _materials[index];
} }
Ref<Material> PropMaterialCache::material_lod_get(const int index) { Ref<Material> PropMaterialCache2D::material_lod_get(const int index) {
ERR_FAIL_COND_V(_materials.size() == 0, Ref<Material>(NULL)); ERR_FAIL_COND_V(_materials.size() == 0, Ref<Material>(NULL));
if (index < 0) { if (index < 0) {
@ -105,35 +105,35 @@ Ref<Material> PropMaterialCache::material_lod_get(const int index) {
return _materials[index]; return _materials[index];
} }
void PropMaterialCache::material_add(const Ref<Material> &value) { void PropMaterialCache2D::material_add(const Ref<Material> &value) {
ERR_FAIL_COND(!value.is_valid()); ERR_FAIL_COND(!value.is_valid());
_materials.push_back(value); _materials.push_back(value);
} }
void PropMaterialCache::material_set(const int index, const Ref<Material> &value) { void PropMaterialCache2D::material_set(const int index, const Ref<Material> &value) {
ERR_FAIL_INDEX(index, _materials.size()); ERR_FAIL_INDEX(index, _materials.size());
_materials.set(index, value); _materials.set(index, value);
} }
void PropMaterialCache::material_remove(const int index) { void PropMaterialCache2D::material_remove(const int index) {
_materials.remove(index); _materials.remove(index);
} }
int PropMaterialCache::material_get_num() const { int PropMaterialCache2D::material_get_num() const {
return _materials.size(); return _materials.size();
} }
void PropMaterialCache::materials_clear() { void PropMaterialCache2D::materials_clear() {
_materials.clear(); _materials.clear();
} }
Vector<Variant> PropMaterialCache::materials_get() { Vector<Variant> PropMaterialCache2D::materials_get() {
VARIANT_ARRAY_GET(_materials); VARIANT_ARRAY_GET(_materials);
} }
void PropMaterialCache::materials_set(const Vector<Variant> &materials) { void PropMaterialCache2D::materials_set(const Vector<Variant> &materials) {
_materials.clear(); _materials.clear();
for (int i = 0; i < materials.size(); i++) { for (int i = 0; i < materials.size(); i++) {
@ -143,10 +143,10 @@ void PropMaterialCache::materials_set(const Vector<Variant> &materials) {
} }
} }
void PropMaterialCache::texture_add(const Ref<Texture> &texture) { void PropMaterialCache2D::texture_add(const Ref<Texture> &texture) {
_textures.push_back(texture); _textures.push_back(texture);
} }
void PropMaterialCache::texture_remove(const Ref<Texture> &texture) { void PropMaterialCache2D::texture_remove(const Ref<Texture> &texture) {
for (int i = 0; i < _textures.size(); ++i) { for (int i = 0; i < _textures.size(); ++i) {
if (_textures[i] == texture) { if (_textures[i] == texture) {
_textures.remove(i); _textures.remove(i);
@ -154,42 +154,42 @@ void PropMaterialCache::texture_remove(const Ref<Texture> &texture) {
} }
} }
} }
void PropMaterialCache::texture_remove_index(const int index) { void PropMaterialCache2D::texture_remove_index(const int index) {
ERR_FAIL_INDEX(index, _textures.size()); ERR_FAIL_INDEX(index, _textures.size());
_textures.remove(index); _textures.remove(index);
} }
void PropMaterialCache::textures_clear() { void PropMaterialCache2D::textures_clear() {
_textures.clear(); _textures.clear();
} }
int PropMaterialCache::texture_count() { int PropMaterialCache2D::texture_count() {
return _textures.size(); return _textures.size();
} }
Ref<Texture> PropMaterialCache::texture_get(const int index) { Ref<Texture> PropMaterialCache2D::texture_get(const int index) {
ERR_FAIL_INDEX_V(index, _textures.size(), Ref<Texture>()); ERR_FAIL_INDEX_V(index, _textures.size(), Ref<Texture>());
return _textures[index]; return _textures[index];
} }
Ref<AtlasTexture> PropMaterialCache::texture_get_atlas(const int index) { Ref<AtlasTexture> PropMaterialCache2D::texture_get_atlas(const int index) {
ERR_FAIL_INDEX_V(index, _textures.size(), Ref<AtlasTexture>()); ERR_FAIL_INDEX_V(index, _textures.size(), Ref<AtlasTexture>());
return texture_get_atlas_tex(_textures[index]); return texture_get_atlas_tex(_textures[index]);
} }
Ref<AtlasTexture> PropMaterialCache::texture_get_atlas_tex(const Ref<Texture> &texture) { Ref<AtlasTexture> PropMaterialCache2D::texture_get_atlas_tex(const Ref<Texture> &texture) {
return Ref<AtlasTexture>(); return Ref<AtlasTexture>();
} }
Rect2 PropMaterialCache::texture_get_uv_rect(const Ref<Texture> &texture) { Rect2 PropMaterialCache2D::texture_get_uv_rect(const Ref<Texture> &texture) {
return Rect2(0, 0, 1, 1); return Rect2(0, 0, 1, 1);
} }
void PropMaterialCache::prop_add_textures(const Ref<PropData> &prop) { void PropMaterialCache2D::prop_add_textures(const Ref<PropData2D> &prop) {
if (!prop.is_valid()) { if (!prop.is_valid()) {
return; return;
} }
for (int i = 0; i < prop->get_prop_count(); ++i) { for (int i = 0; i < prop->get_prop_count(); ++i) {
#if MESH_DATA_RESOURCE_PRESENT #if MESH_DATA_RESOURCE_PRESENT
Ref<PropDataMeshData> pdm = prop->get_prop(i); Ref<PropData2DMeshData> pdm = prop->get_prop(i);
if (pdm.is_valid()) { if (pdm.is_valid()) {
Ref<Texture> tex = pdm->get_texture(); Ref<Texture> tex = pdm->get_texture();
@ -203,34 +203,34 @@ void PropMaterialCache::prop_add_textures(const Ref<PropData> &prop) {
} }
#endif #endif
Ref<PropDataTiledWall> pdtw = prop->get_prop(i); Ref<PropDataTiledWall2D> pdtw = prop->get_prop(i);
if (pdtw.is_valid()) { if (pdtw.is_valid()) {
Ref<TiledWallData> twd = pdtw->get_data(); Ref<TiledWallData2D> twd = pdtw->get_data();
if (!twd.is_valid()) if (!twd.is_valid())
continue; continue;
twd->setup_cache(Ref<PropMaterialCache>(this)); twd->setup_cache(Ref<PropMaterialCache2D>(this));
continue; continue;
} }
Ref<PropDataProp> pdp = prop->get_prop(i); Ref<PropDataProp2D> pdp = prop->get_prop(i);
if (pdp.is_valid()) { if (pdp.is_valid()) {
prop_add_textures(pdp->get_prop()); prop_add_textures(pdp->get_prop());
} }
} }
} }
void PropMaterialCache::prop_remove_textures(const Ref<PropData> &prop) { void PropMaterialCache2D::prop_remove_textures(const Ref<PropData2D> &prop) {
if (!prop.is_valid()) { if (!prop.is_valid()) {
return; return;
} }
for (int i = 0; i < prop->get_prop_count(); ++i) { for (int i = 0; i < prop->get_prop_count(); ++i) {
#if MESH_DATA_RESOURCE_PRESENT #if MESH_DATA_RESOURCE_PRESENT
Ref<PropDataMeshData> pdm = prop->get_prop(i); Ref<PropData2DMeshData> pdm = prop->get_prop(i);
if (pdm.is_valid()) { if (pdm.is_valid()) {
Ref<Texture> tex = pdm->get_texture(); Ref<Texture> tex = pdm->get_texture();
@ -242,10 +242,10 @@ void PropMaterialCache::prop_remove_textures(const Ref<PropData> &prop) {
} }
#endif #endif
Ref<PropDataTiledWall> pdtw = prop->get_prop(i); Ref<PropDataTiledWall2D> pdtw = prop->get_prop(i);
if (pdtw.is_valid()) { if (pdtw.is_valid()) {
Ref<TiledWallData> twd = pdtw->get_data(); Ref<TiledWallData2D> twd = pdtw->get_data();
if (!twd.is_valid()) if (!twd.is_valid())
continue; continue;
@ -269,7 +269,7 @@ void PropMaterialCache::prop_remove_textures(const Ref<PropData> &prop) {
continue; continue;
} }
Ref<PropDataProp> pdp = prop->get_prop(i); Ref<PropDataProp2D> pdp = prop->get_prop(i);
if (pdp.is_valid()) { if (pdp.is_valid()) {
prop_remove_textures(pdp); prop_remove_textures(pdp);
@ -277,14 +277,14 @@ void PropMaterialCache::prop_remove_textures(const Ref<PropData> &prop) {
} }
} }
void PropMaterialCache::refresh_rects() { void PropMaterialCache2D::refresh_rects() {
_initialized = true; _initialized = true;
} }
void PropMaterialCache::initial_setup_default() { void PropMaterialCache2D::initial_setup_default() {
//Note: call only on the main thread! Shader->duplicate() can crash if done from an another thread! //Note: call only on the main thread! Shader->duplicate() can crash if done from an another thread!
PropCache *pc = PropCache::get_singleton(); PropCache2D *pc = PropCache2D::get_singleton();
pc->ensure_materials_loaded(); pc->ensure_materials_loaded();
@ -300,64 +300,64 @@ void PropMaterialCache::initial_setup_default() {
} }
} }
void PropMaterialCache::setup_material_albedo(Ref<Texture> texture) { void PropMaterialCache2D::setup_material_albedo(Ref<Texture> texture) {
if (has_method("_setup_material_albedo")) if (has_method("_setup_material_albedo"))
call("_setup_material_albedo", texture); call("_setup_material_albedo", texture);
} }
PropMaterialCache::PropMaterialCache() { PropMaterialCache2D::PropMaterialCache2D() {
_ref_count = 0; _ref_count = 0;
_initialized = false; _initialized = false;
_locked = false; _locked = false;
} }
PropMaterialCache::~PropMaterialCache() { PropMaterialCache2D::~PropMaterialCache2D() {
_materials.clear(); _materials.clear();
} }
void PropMaterialCache::_bind_methods() { void PropMaterialCache2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_initialized"), &PropMaterialCache::get_initialized); ClassDB::bind_method(D_METHOD("get_initialized"), &PropMaterialCache2D::get_initialized);
ClassDB::bind_method(D_METHOD("set_initialized", "value"), &PropMaterialCache::set_initialized); ClassDB::bind_method(D_METHOD("set_initialized", "value"), &PropMaterialCache2D::set_initialized);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "initialized"), "set_initialized", "get_initialized"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "initialized"), "set_initialized", "get_initialized");
ClassDB::bind_method(D_METHOD("mutex_locked"), &PropMaterialCache::mutex_locked); ClassDB::bind_method(D_METHOD("mutex_locked"), &PropMaterialCache2D::mutex_locked);
ClassDB::bind_method(D_METHOD("mutex_lock"), &PropMaterialCache::mutex_lock); ClassDB::bind_method(D_METHOD("mutex_lock"), &PropMaterialCache2D::mutex_lock);
ClassDB::bind_method(D_METHOD("mutex_unlock"), &PropMaterialCache::mutex_unlock); ClassDB::bind_method(D_METHOD("mutex_unlock"), &PropMaterialCache2D::mutex_unlock);
ClassDB::bind_method(D_METHOD("get_ref_count"), &PropMaterialCache::get_ref_count); ClassDB::bind_method(D_METHOD("get_ref_count"), &PropMaterialCache2D::get_ref_count);
ClassDB::bind_method(D_METHOD("set_ref_count", "value"), &PropMaterialCache::set_ref_count); ClassDB::bind_method(D_METHOD("set_ref_count", "value"), &PropMaterialCache2D::set_ref_count);
ADD_PROPERTY(PropertyInfo(Variant::INT, "mat_ref_count"), "set_ref_count", "get_ref_count"); ADD_PROPERTY(PropertyInfo(Variant::INT, "mat_ref_count"), "set_ref_count", "get_ref_count");
ClassDB::bind_method(D_METHOD("inc_ref_count"), &PropMaterialCache::inc_ref_count); ClassDB::bind_method(D_METHOD("inc_ref_count"), &PropMaterialCache2D::inc_ref_count);
ClassDB::bind_method(D_METHOD("dec_ref_count"), &PropMaterialCache::dec_ref_count); ClassDB::bind_method(D_METHOD("dec_ref_count"), &PropMaterialCache2D::dec_ref_count);
BIND_VMETHOD(MethodInfo("_setup_material_albedo", PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"))); BIND_VMETHOD(MethodInfo("_setup_material_albedo", PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture")));
ClassDB::bind_method(D_METHOD("material_get", "index"), &PropMaterialCache::material_get); ClassDB::bind_method(D_METHOD("material_get", "index"), &PropMaterialCache2D::material_get);
ClassDB::bind_method(D_METHOD("material_lod_get", "index"), &PropMaterialCache::material_lod_get); ClassDB::bind_method(D_METHOD("material_lod_get", "index"), &PropMaterialCache2D::material_lod_get);
ClassDB::bind_method(D_METHOD("material_add", "value"), &PropMaterialCache::material_add); ClassDB::bind_method(D_METHOD("material_add", "value"), &PropMaterialCache2D::material_add);
ClassDB::bind_method(D_METHOD("material_set", "index", "value"), &PropMaterialCache::material_set); ClassDB::bind_method(D_METHOD("material_set", "index", "value"), &PropMaterialCache2D::material_set);
ClassDB::bind_method(D_METHOD("material_remove", "index"), &PropMaterialCache::material_remove); ClassDB::bind_method(D_METHOD("material_remove", "index"), &PropMaterialCache2D::material_remove);
ClassDB::bind_method(D_METHOD("material_get_num"), &PropMaterialCache::material_get_num); ClassDB::bind_method(D_METHOD("material_get_num"), &PropMaterialCache2D::material_get_num);
ClassDB::bind_method(D_METHOD("materials_clear"), &PropMaterialCache::materials_clear); ClassDB::bind_method(D_METHOD("materials_clear"), &PropMaterialCache2D::materials_clear);
ClassDB::bind_method(D_METHOD("materials_get"), &PropMaterialCache::materials_get); ClassDB::bind_method(D_METHOD("materials_get"), &PropMaterialCache2D::materials_get);
ClassDB::bind_method(D_METHOD("materials_set"), &PropMaterialCache::materials_set); ClassDB::bind_method(D_METHOD("materials_set"), &PropMaterialCache2D::materials_set);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "materials_set", "materials_get"); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "materials_set", "materials_get");
ClassDB::bind_method(D_METHOD("texture_add", "texture"), &PropMaterialCache::texture_add); ClassDB::bind_method(D_METHOD("texture_add", "texture"), &PropMaterialCache2D::texture_add);
ClassDB::bind_method(D_METHOD("texture_remove", "texture"), &PropMaterialCache::texture_remove); ClassDB::bind_method(D_METHOD("texture_remove", "texture"), &PropMaterialCache2D::texture_remove);
ClassDB::bind_method(D_METHOD("texture_remove_index", "index"), &PropMaterialCache::texture_remove_index); ClassDB::bind_method(D_METHOD("texture_remove_index", "index"), &PropMaterialCache2D::texture_remove_index);
ClassDB::bind_method(D_METHOD("textures_clear"), &PropMaterialCache::textures_clear); ClassDB::bind_method(D_METHOD("textures_clear"), &PropMaterialCache2D::textures_clear);
ClassDB::bind_method(D_METHOD("texture_count"), &PropMaterialCache::texture_count); ClassDB::bind_method(D_METHOD("texture_count"), &PropMaterialCache2D::texture_count);
ClassDB::bind_method(D_METHOD("texture_get", "index"), &PropMaterialCache::texture_get); ClassDB::bind_method(D_METHOD("texture_get", "index"), &PropMaterialCache2D::texture_get);
ClassDB::bind_method(D_METHOD("texture_get_atlas", "index"), &PropMaterialCache::texture_get_atlas); ClassDB::bind_method(D_METHOD("texture_get_atlas", "index"), &PropMaterialCache2D::texture_get_atlas);
ClassDB::bind_method(D_METHOD("texture_get_atlas_tex", "index"), &PropMaterialCache::texture_get_atlas_tex); ClassDB::bind_method(D_METHOD("texture_get_atlas_tex", "index"), &PropMaterialCache2D::texture_get_atlas_tex);
ClassDB::bind_method(D_METHOD("texture_get_uv_rect", "texture"), &PropMaterialCache::texture_get_uv_rect); ClassDB::bind_method(D_METHOD("texture_get_uv_rect", "texture"), &PropMaterialCache2D::texture_get_uv_rect);
ClassDB::bind_method(D_METHOD("prop_add_textures", "prop"), &PropMaterialCache::prop_add_textures); ClassDB::bind_method(D_METHOD("prop_add_textures", "prop"), &PropMaterialCache2D::prop_add_textures);
ClassDB::bind_method(D_METHOD("prop_remove_textures", "prop"), &PropMaterialCache::prop_remove_textures); ClassDB::bind_method(D_METHOD("prop_remove_textures", "prop"), &PropMaterialCache2D::prop_remove_textures);
ClassDB::bind_method(D_METHOD("refresh_rects"), &PropMaterialCache::refresh_rects); ClassDB::bind_method(D_METHOD("refresh_rects"), &PropMaterialCache2D::refresh_rects);
ClassDB::bind_method(D_METHOD("setup_material_albedo", "texture"), &PropMaterialCache::setup_material_albedo); ClassDB::bind_method(D_METHOD("setup_material_albedo", "texture"), &PropMaterialCache2D::setup_material_albedo);
} }

14
material_cache/prop_material_cache_2d.h
View File

@ -39,10 +39,10 @@ SOFTWARE.
#include "scene/resources/material.h" #include "scene/resources/material.h"
#include "core/os/mutex.h" #include "core/os/mutex.h"
class PropData; class PropData2D;
class PropMaterialCache : public Resource { class PropMaterialCache2D : public Resource {
GDCLASS(PropMaterialCache, Resource) GDCLASS(PropMaterialCache2D, Resource)
public: public:
bool get_initialized(); bool get_initialized();
@ -78,8 +78,8 @@ public:
virtual Ref<AtlasTexture> texture_get_atlas_tex(const Ref<Texture> &texture); virtual Ref<AtlasTexture> texture_get_atlas_tex(const Ref<Texture> &texture);
virtual Rect2 texture_get_uv_rect(const Ref<Texture> &texture); virtual Rect2 texture_get_uv_rect(const Ref<Texture> &texture);
void prop_add_textures(const Ref<PropData> &prop); void prop_add_textures(const Ref<PropData2D> &prop);
void prop_remove_textures(const Ref<PropData> &prop); void prop_remove_textures(const Ref<PropData2D> &prop);
virtual void refresh_rects(); virtual void refresh_rects();
@ -87,8 +87,8 @@ public:
void setup_material_albedo(Ref<Texture> texture); void setup_material_albedo(Ref<Texture> texture);
PropMaterialCache(); PropMaterialCache2D();
~PropMaterialCache(); ~PropMaterialCache2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();

62
material_cache/prop_material_cache_pcm_2d.cpp
View File

@ -26,49 +26,49 @@ SOFTWARE.
#include "../singleton/prop_cache_2d.h" #include "../singleton/prop_cache_2d.h"
#include "scene/resources/texture.h" #include "scene/resources/texture.h"
int PropMaterialCachePCM::get_texture_flags() const { int PropMaterialCachePCM2D::get_texture_flags() const {
return _packer->get_texture_flags(); return _packer->get_texture_flags();
} }
void PropMaterialCachePCM::set_texture_flags(const int flags) { void PropMaterialCachePCM2D::set_texture_flags(const int flags) {
_packer->set_texture_flags(flags); _packer->set_texture_flags(flags);
} }
int PropMaterialCachePCM::get_max_atlas_size() const { int PropMaterialCachePCM2D::get_max_atlas_size() const {
return _packer->get_max_atlas_size(); return _packer->get_max_atlas_size();
} }
void PropMaterialCachePCM::set_max_atlas_size(const int size) { void PropMaterialCachePCM2D::set_max_atlas_size(const int size) {
_packer->set_max_atlas_size(size); _packer->set_max_atlas_size(size);
} }
bool PropMaterialCachePCM::get_keep_original_atlases() const { bool PropMaterialCachePCM2D::get_keep_original_atlases() const {
return _packer->get_keep_original_atlases(); return _packer->get_keep_original_atlases();
} }
void PropMaterialCachePCM::set_keep_original_atlases(const bool value) { void PropMaterialCachePCM2D::set_keep_original_atlases(const bool value) {
_packer->set_keep_original_atlases(value); _packer->set_keep_original_atlases(value);
} }
Color PropMaterialCachePCM::get_background_color() const { Color PropMaterialCachePCM2D::get_background_color() const {
return _packer->get_background_color(); return _packer->get_background_color();
} }
void PropMaterialCachePCM::set_background_color(const Color &color) { void PropMaterialCachePCM2D::set_background_color(const Color &color) {
_packer->set_background_color(color); _packer->set_background_color(color);
} }
int PropMaterialCachePCM::get_margin() const { int PropMaterialCachePCM2D::get_margin() const {
return _packer->get_margin(); return _packer->get_margin();
} }
void PropMaterialCachePCM::set_margin(const int margin) { void PropMaterialCachePCM2D::set_margin(const int margin) {
_packer->set_margin(margin); _packer->set_margin(margin);
} }
Ref<AtlasTexture> PropMaterialCachePCM::texture_get_atlas_tex(const Ref<Texture> &texture) { Ref<AtlasTexture> PropMaterialCachePCM2D::texture_get_atlas_tex(const Ref<Texture> &texture) {
if (!_packer->contains_texture(texture)) { if (!_packer->contains_texture(texture)) {
return Ref<AtlasTexture>(); return Ref<AtlasTexture>();
} }
return _packer->get_texture(texture); return _packer->get_texture(texture);
} }
Rect2 PropMaterialCachePCM::texture_get_uv_rect(const Ref<Texture> &texture) { Rect2 PropMaterialCachePCM2D::texture_get_uv_rect(const Ref<Texture> &texture) {
if (!texture.is_valid()) { if (!texture.is_valid()) {
return Rect2(0, 0, 1, 1); return Rect2(0, 0, 1, 1);
} }
@ -102,7 +102,7 @@ Rect2 PropMaterialCachePCM::texture_get_uv_rect(const Ref<Texture> &texture) {
return region; return region;
} }
void PropMaterialCachePCM::refresh_rects() { void PropMaterialCachePCM2D::refresh_rects() {
bool texture_added = false; bool texture_added = false;
for (int i = 0; i < _textures.size(); i++) { for (int i = 0; i < _textures.size(); i++) {
@ -129,10 +129,10 @@ void PropMaterialCachePCM::refresh_rects() {
_initialized = true; _initialized = true;
} }
void PropMaterialCachePCM::initial_setup_default() { void PropMaterialCachePCM2D::initial_setup_default() {
PropMaterialCache::initial_setup_default(); PropMaterialCache2D::initial_setup_default();
PropCache *pc = PropCache::get_singleton(); PropCache2D *pc = PropCache2D::get_singleton();
set_texture_flags(pc->get_texture_flags()); set_texture_flags(pc->get_texture_flags());
set_max_atlas_size(pc->get_max_atlas_size()); set_max_atlas_size(pc->get_max_atlas_size());
@ -141,7 +141,7 @@ void PropMaterialCachePCM::initial_setup_default() {
set_margin(pc->get_margin()); set_margin(pc->get_margin());
} }
void PropMaterialCachePCM::_setup_material_albedo(Ref<Texture> texture) { void PropMaterialCachePCM2D::_setup_material_albedo(Ref<Texture> texture) {
int count = material_get_num(); int count = material_get_num();
for (int i = 0; i < count; ++i) { for (int i = 0; i < count; ++i) {
@ -162,7 +162,7 @@ void PropMaterialCachePCM::_setup_material_albedo(Ref<Texture> texture) {
} }
} }
PropMaterialCachePCM::PropMaterialCachePCM() { PropMaterialCachePCM2D::PropMaterialCachePCM2D() {
_packer.instance(); _packer.instance();
#if GODOT4 #if GODOT4
@ -176,31 +176,31 @@ PropMaterialCachePCM::PropMaterialCachePCM() {
_packer->set_margin(0); _packer->set_margin(0);
} }
PropMaterialCachePCM::~PropMaterialCachePCM() { PropMaterialCachePCM2D::~PropMaterialCachePCM2D() {
_packer->clear(); _packer->clear();
_packer.unref(); _packer.unref();
} }
void PropMaterialCachePCM::_bind_methods() { void PropMaterialCachePCM2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_texture_flags"), &PropMaterialCachePCM::get_texture_flags); ClassDB::bind_method(D_METHOD("get_texture_flags"), &PropMaterialCachePCM2D::get_texture_flags);
ClassDB::bind_method(D_METHOD("set_texture_flags", "flags"), &PropMaterialCachePCM::set_texture_flags); ClassDB::bind_method(D_METHOD("set_texture_flags", "flags"), &PropMaterialCachePCM2D::set_texture_flags);
ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_flags", PROPERTY_HINT_FLAGS, "Mipmaps,Repeat,Filter,Anisotropic Linear,Convert to Linear,Mirrored Repeat,Video Surface"), "set_texture_flags", "get_texture_flags"); ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_flags", PROPERTY_HINT_FLAGS, "Mipmaps,Repeat,Filter,Anisotropic Linear,Convert to Linear,Mirrored Repeat,Video Surface"), "set_texture_flags", "get_texture_flags");
ClassDB::bind_method(D_METHOD("get_max_atlas_size"), &PropMaterialCachePCM::get_max_atlas_size); ClassDB::bind_method(D_METHOD("get_max_atlas_size"), &PropMaterialCachePCM2D::get_max_atlas_size);
ClassDB::bind_method(D_METHOD("set_max_atlas_size", "size"), &PropMaterialCachePCM::set_max_atlas_size); ClassDB::bind_method(D_METHOD("set_max_atlas_size", "size"), &PropMaterialCachePCM2D::set_max_atlas_size);
ADD_PROPERTY(PropertyInfo(Variant::INT, "max_atlas_size"), "set_max_atlas_size", "get_max_atlas_size"); ADD_PROPERTY(PropertyInfo(Variant::INT, "max_atlas_size"), "set_max_atlas_size", "get_max_atlas_size");
ClassDB::bind_method(D_METHOD("get_keep_original_atlases"), &PropMaterialCachePCM::get_keep_original_atlases); ClassDB::bind_method(D_METHOD("get_keep_original_atlases"), &PropMaterialCachePCM2D::get_keep_original_atlases);
ClassDB::bind_method(D_METHOD("set_keep_original_atlases", "value"), &PropMaterialCachePCM::set_keep_original_atlases); ClassDB::bind_method(D_METHOD("set_keep_original_atlases", "value"), &PropMaterialCachePCM2D::set_keep_original_atlases);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "keep_original_atlases"), "set_keep_original_atlases", "get_keep_original_atlases"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "keep_original_atlases"), "set_keep_original_atlases", "get_keep_original_atlases");
ClassDB::bind_method(D_METHOD("get_background_color"), &PropMaterialCachePCM::get_background_color); ClassDB::bind_method(D_METHOD("get_background_color"), &PropMaterialCachePCM2D::get_background_color);
ClassDB::bind_method(D_METHOD("set_background_color", "color"), &PropMaterialCachePCM::set_background_color); ClassDB::bind_method(D_METHOD("set_background_color", "color"), &PropMaterialCachePCM2D::set_background_color);
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "background_color"), "set_background_color", "get_background_color"); ADD_PROPERTY(PropertyInfo(Variant::COLOR, "background_color"), "set_background_color", "get_background_color");
ClassDB::bind_method(D_METHOD("get_margin"), &PropMaterialCachePCM::get_margin); ClassDB::bind_method(D_METHOD("get_margin"), &PropMaterialCachePCM2D::get_margin);
ClassDB::bind_method(D_METHOD("set_margin", "size"), &PropMaterialCachePCM::set_margin); ClassDB::bind_method(D_METHOD("set_margin", "size"), &PropMaterialCachePCM2D::set_margin);
ADD_PROPERTY(PropertyInfo(Variant::INT, "margin"), "set_margin", "get_margin"); ADD_PROPERTY(PropertyInfo(Variant::INT, "margin"), "set_margin", "get_margin");
ClassDB::bind_method(D_METHOD("_setup_material_albedo", "texture"), &PropMaterialCachePCM::_setup_material_albedo); ClassDB::bind_method(D_METHOD("_setup_material_albedo", "texture"), &PropMaterialCachePCM2D::_setup_material_albedo);
} }

8
material_cache/prop_material_cache_pcm_2d.h
View File

@ -43,8 +43,8 @@ SOFTWARE.
class TexturePacker; class TexturePacker;
class PropData; class PropData;
class PropMaterialCachePCM : public PropMaterialCache { class PropMaterialCachePCM2D : public PropMaterialCache2D {
GDCLASS(PropMaterialCachePCM, PropMaterialCache); GDCLASS(PropMaterialCachePCM2D, PropMaterialCache2D);
public: public:
int get_texture_flags() const; int get_texture_flags() const;
@ -71,8 +71,8 @@ public:
void _setup_material_albedo(Ref<Texture> texture); void _setup_material_albedo(Ref<Texture> texture);
PropMaterialCachePCM(); PropMaterialCachePCM2D();
~PropMaterialCachePCM(); ~PropMaterialCachePCM2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();

6
prop_ess_entity_2d.cpp
View File

@ -1,9 +1,9 @@
#include "prop_ess_entity_2d.h" #include "prop_ess_entity_2d.h"
PropESSEntity::PropESSEntity() { PropESSEntity2D::PropESSEntity2D() {
} }
PropESSEntity::~PropESSEntity() { PropESSEntity2D::~PropESSEntity2D() {
} }
void PropESSEntity::_bind_methods() { void PropESSEntity2D::_bind_methods() {
} }

8
prop_ess_entity_2d.h
View File

@ -35,13 +35,13 @@ SOFTWARE.
#include "core/math/vector3.h" #include "core/math/vector3.h"
class PropESSEntity : public Spatial { class PropESSEntity2D : public Spatial {
GDCLASS(PropESSEntity, Spatial); GDCLASS(PropESSEntity2D, Spatial);
OBJ_CATEGORY("Props"); OBJ_CATEGORY("Props");
public: public:
PropESSEntity(); PropESSEntity2D();
~PropESSEntity(); ~PropESSEntity2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();

100
prop_instance_2d.cpp
View File

@ -28,10 +28,10 @@
#include "tiled_wall/tiled_wall_2d.h" #include "tiled_wall/tiled_wall_2d.h"
#include "tiled_wall/tiled_wall_data_2d.h" #include "tiled_wall/tiled_wall_data_2d.h"
Ref<PropData> PropInstance::get_prop_data() { Ref<PropData2D> PropInstance2D::get_prop_data() {
return _prop_data; return _prop_data;
} }
void PropInstance::set_prop_data(const Ref<PropData> &data) { void PropInstance2D::set_prop_data(const Ref<PropData2D> &data) {
if (_prop_data == data) if (_prop_data == data)
return; return;
@ -44,58 +44,58 @@ void PropInstance::set_prop_data(const Ref<PropData> &data) {
} }
} }
Ref<Material> PropInstance::get_material() { Ref<Material> PropInstance2D::get_material() {
return _material; return _material;
} }
void PropInstance::set_material(const Ref<Material> &material) { void PropInstance2D::set_material(const Ref<Material> &material) {
_material = material; _material = material;
} }
uint32_t PropInstance::get_collision_layer() const { uint32_t PropInstance2D::get_collision_layer() const {
return _collision_layer; return _collision_layer;
} }
void PropInstance::set_collision_layer(uint32_t p_layer) { void PropInstance2D::set_collision_layer(uint32_t p_layer) {
_collision_layer = p_layer; _collision_layer = p_layer;
collision_layer_changed(); collision_layer_changed();
} }
uint32_t PropInstance::get_collision_mask() const { uint32_t PropInstance2D::get_collision_mask() const {
return _collision_mask; return _collision_mask;
} }
void PropInstance::set_collision_mask(uint32_t p_mask) { void PropInstance2D::set_collision_mask(uint32_t p_mask) {
_collision_mask = p_mask; _collision_mask = p_mask;
collision_mask_changed(); collision_mask_changed();
} }
void PropInstance::collision_layer_changed() { void PropInstance2D::collision_layer_changed() {
} }
void PropInstance::collision_mask_changed() { void PropInstance2D::collision_mask_changed() {
} }
void PropInstance::init_materials() { void PropInstance2D::init_materials() {
call("_init_materials"); call("_init_materials");
} }
void PropInstance::_init_materials() { void PropInstance2D::_init_materials() {
} }
void PropInstance::build() { void PropInstance2D::build() {
call("_build"); call("_build");
} }
void PropInstance::queue_build() { void PropInstance2D::queue_build() {
_build_queued = true; _build_queued = true;
} }
void PropInstance::build_finished() { void PropInstance2D::build_finished() {
call("_build_finished"); call("_build_finished");
} }
void PropInstance::_build() { void PropInstance2D::_build() {
_building = true; _building = true;
_build_queued = false; _build_queued = false;
@ -118,7 +118,7 @@ void PropInstance::_build() {
prop_preprocess(Transform(), _prop_data); prop_preprocess(Transform(), _prop_data);
} }
void PropInstance::_build_finished() { void PropInstance2D::_build_finished() {
_building = false; _building = false;
if (_build_queued) { if (_build_queued) {
@ -126,28 +126,28 @@ void PropInstance::_build_finished() {
} }
} }
void PropInstance::prop_preprocess(Transform transform, const Ref<PropData> &prop) { void PropInstance2D::prop_preprocess(Transform transform, const Ref<PropData2D> &prop) {
call("_prop_preprocess", transform, prop); call("_prop_preprocess", transform, prop);
} }
void PropInstance::_prop_preprocess(Transform transform, const Ref<PropData> &prop) { void PropInstance2D::_prop_preprocess(Transform transform, const Ref<PropData2D> &prop) {
//don't set owners, to help working with the editor //don't set owners, to help working with the editor
ERR_FAIL_COND(!prop.is_valid()); ERR_FAIL_COND(!prop.is_valid());
int count = prop->get_prop_count(); int count = prop->get_prop_count();
for (int i = 0; i < count; ++i) { for (int i = 0; i < count; ++i) {
Ref<PropDataEntry> e = prop->get_prop(i); Ref<PropDataEntry2D> e = prop->get_prop(i);
if (!e.is_valid()) if (!e.is_valid())
continue; continue;
Transform t = transform * e->get_transform(); Transform t = transform * e->get_transform();
Ref<PropDataProp> prop_entry_data = e; Ref<PropDataProp2D> prop_entry_data = e;
if (prop_entry_data.is_valid()) { if (prop_entry_data.is_valid()) {
Ref<PropData> p = prop_entry_data->get_prop(); Ref<PropData2D> p = prop_entry_data->get_prop();
if (!p.is_valid()) if (!p.is_valid())
continue; continue;
@ -157,10 +157,10 @@ void PropInstance::_prop_preprocess(Transform transform, const Ref<PropData> &pr
continue; continue;
} }
Ref<PropDataTiledWall> tiled_wall_data = e; Ref<PropDataTiledWall2D> tiled_wall_data = e;
if (tiled_wall_data.is_valid()) { if (tiled_wall_data.is_valid()) {
TiledWall *twn = memnew(TiledWall); TiledWall2D *twn = memnew(TiledWall2D);
twn->set_width(tiled_wall_data->get_width()); twn->set_width(tiled_wall_data->get_width());
twn->set_heigth(tiled_wall_data->get_heigth()); twn->set_heigth(tiled_wall_data->get_heigth());
@ -174,7 +174,7 @@ void PropInstance::_prop_preprocess(Transform transform, const Ref<PropData> &pr
continue; continue;
} }
Ref<PropDataScene> scene_data = e; Ref<PropDataScene2D> scene_data = e;
if (scene_data.is_valid()) { if (scene_data.is_valid()) {
Ref<PackedScene> sc = scene_data->get_scene(); Ref<PackedScene> sc = scene_data->get_scene();
@ -194,7 +194,7 @@ void PropInstance::_prop_preprocess(Transform transform, const Ref<PropData> &pr
continue; continue;
} }
Ref<PropDataLight> light_data = e; Ref<PropDataLight2D> light_data = e;
if (light_data.is_valid()) { if (light_data.is_valid()) {
OmniLight *light = memnew(OmniLight); OmniLight *light = memnew(OmniLight);
@ -207,7 +207,7 @@ void PropInstance::_prop_preprocess(Transform transform, const Ref<PropData> &pr
} }
#if MESH_DATA_RESOURCE_PRESENT #if MESH_DATA_RESOURCE_PRESENT
Ref<PropDataMeshData> mesh_data = e; Ref<PropDataMeshData2D> mesh_data = e;
if (mesh_data.is_valid()) { if (mesh_data.is_valid()) {
Ref<MeshDataResource> mdr = mesh_data->get_mesh(); Ref<MeshDataResource> mdr = mesh_data->get_mesh();
@ -251,7 +251,7 @@ void PropInstance::_prop_preprocess(Transform transform, const Ref<PropData> &pr
} }
} }
PropInstance::PropInstance() { PropInstance2D::PropInstance2D() {
_build_queued = false; _build_queued = false;
_building = false; _building = false;
@ -259,11 +259,11 @@ PropInstance::PropInstance() {
_collision_mask = 1; _collision_mask = 1;
} }
PropInstance::~PropInstance() { PropInstance2D::~PropInstance2D() {
_prop_data.unref(); _prop_data.unref();
} }
void PropInstance::_notification(int p_what) { void PropInstance2D::_notification(int p_what) {
switch (p_what) { switch (p_what) {
case NOTIFICATION_ENTER_TREE: { case NOTIFICATION_ENTER_TREE: {
if (_prop_data.is_valid()) { if (_prop_data.is_valid()) {
@ -275,20 +275,20 @@ void PropInstance::_notification(int p_what) {
} }
} }
void PropInstance::_bind_methods() { void PropInstance2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_prop_data"), &PropInstance::get_prop_data); ClassDB::bind_method(D_METHOD("get_prop_data"), &PropInstance2D::get_prop_data);
ClassDB::bind_method(D_METHOD("set_prop_data", "value"), &PropInstance::set_prop_data); ClassDB::bind_method(D_METHOD("set_prop_data", "value"), &PropInstance2D::set_prop_data);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "prop_data", PROPERTY_HINT_RESOURCE_TYPE, "PropData"), "set_prop_data", "get_prop_data"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "prop_data", PROPERTY_HINT_RESOURCE_TYPE, "PropData2D"), "set_prop_data", "get_prop_data");
ClassDB::bind_method(D_METHOD("get_material"), &PropInstance::get_material); ClassDB::bind_method(D_METHOD("get_material"), &PropInstance2D::get_material);
ClassDB::bind_method(D_METHOD("set_material", "material"), &PropInstance::set_material); ClassDB::bind_method(D_METHOD("set_material", "material"), &PropInstance2D::set_material);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_material", "get_material"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_material", "get_material");
ClassDB::bind_method(D_METHOD("get_collision_layer"), &PropInstance::get_collision_layer); ClassDB::bind_method(D_METHOD("get_collision_layer"), &PropInstance2D::get_collision_layer);
ClassDB::bind_method(D_METHOD("set_collision_layer", "layer"), &PropInstance::set_collision_layer); ClassDB::bind_method(D_METHOD("set_collision_layer", "layer"), &PropInstance2D::set_collision_layer);
ClassDB::bind_method(D_METHOD("get_collision_mask"), &PropInstance::get_collision_mask); ClassDB::bind_method(D_METHOD("get_collision_mask"), &PropInstance2D::get_collision_mask);
ClassDB::bind_method(D_METHOD("set_collision_mask", "layer"), &PropInstance::set_collision_mask); ClassDB::bind_method(D_METHOD("set_collision_mask", "layer"), &PropInstance2D::set_collision_mask);
ADD_GROUP("Collision", "collision_"); ADD_GROUP("Collision", "collision_");
ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_layer", "get_collision_layer"); ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_layer", "get_collision_layer");
@ -296,25 +296,25 @@ void PropInstance::_bind_methods() {
BIND_VMETHOD(MethodInfo("_prop_preprocess", BIND_VMETHOD(MethodInfo("_prop_preprocess",
PropertyInfo(Variant::TRANSFORM, "tarnsform"), PropertyInfo(Variant::TRANSFORM, "tarnsform"),
PropertyInfo(Variant::OBJECT, "prop_data", PROPERTY_HINT_RESOURCE_TYPE, "PropData"))); PropertyInfo(Variant::OBJECT, "prop_data", PROPERTY_HINT_RESOURCE_TYPE, "PropData2D")));
ClassDB::bind_method(D_METHOD("prop_preprocess", "tarnsform", "prop"), &PropInstance::prop_preprocess); ClassDB::bind_method(D_METHOD("prop_preprocess", "tarnsform", "prop"), &PropInstance2D::prop_preprocess);
ClassDB::bind_method(D_METHOD("_prop_preprocess", "tarnsform", "prop"), &PropInstance::_prop_preprocess); ClassDB::bind_method(D_METHOD("_prop_preprocess", "tarnsform", "prop"), &PropInstance2D::_prop_preprocess);
//--- //---
BIND_VMETHOD(MethodInfo("_init_materials")); BIND_VMETHOD(MethodInfo("_init_materials"));
ClassDB::bind_method(D_METHOD("init_materials"), &PropInstance::init_materials); ClassDB::bind_method(D_METHOD("init_materials"), &PropInstance2D::init_materials);
ClassDB::bind_method(D_METHOD("_init_materials"), &PropInstance::_init_materials); ClassDB::bind_method(D_METHOD("_init_materials"), &PropInstance2D::_init_materials);
//--- //---
ClassDB::bind_method(D_METHOD("build"), &PropInstance::build); ClassDB::bind_method(D_METHOD("build"), &PropInstance2D::build);
ClassDB::bind_method(D_METHOD("queue_build"), &PropInstance::queue_build); ClassDB::bind_method(D_METHOD("queue_build"), &PropInstance2D::queue_build);
ClassDB::bind_method(D_METHOD("build_finished"), &PropInstance::build_finished); ClassDB::bind_method(D_METHOD("build_finished"), &PropInstance2D::build_finished);
BIND_VMETHOD(MethodInfo("_build")); BIND_VMETHOD(MethodInfo("_build"));
BIND_VMETHOD(MethodInfo("_build_finished")); BIND_VMETHOD(MethodInfo("_build_finished"));
ClassDB::bind_method(D_METHOD("_build"), &PropInstance::_build); ClassDB::bind_method(D_METHOD("_build"), &PropInstance2D::_build);
ClassDB::bind_method(D_METHOD("_build_finished"), &PropInstance::_build_finished); ClassDB::bind_method(D_METHOD("_build_finished"), &PropInstance2D::_build_finished);
} }

18
prop_instance_2d.h
View File

@ -39,12 +39,12 @@ SOFTWARE.
#include "props/prop_data_2d.h" #include "props/prop_data_2d.h"
class PropInstance : public Spatial { class PropInstance2D : public Spatial {
GDCLASS(PropInstance, Spatial); GDCLASS(PropInstance2D, Spatial);
public: public:
Ref<PropData> get_prop_data(); Ref<PropData2D> get_prop_data();
void set_prop_data(const Ref<PropData> &data); void set_prop_data(const Ref<PropData2D> &data);
Ref<Material> get_material(); Ref<Material> get_material();
void set_material(const Ref<Material> &material); void set_material(const Ref<Material> &material);
@ -68,18 +68,18 @@ public:
virtual void _build(); virtual void _build();
virtual void _build_finished(); virtual void _build_finished();
void prop_preprocess(Transform tarnsform, const Ref<PropData> &prop); void prop_preprocess(Transform tarnsform, const Ref<PropData2D> &prop);
virtual void _prop_preprocess(Transform tarnsform, const Ref<PropData> &prop); virtual void _prop_preprocess(Transform tarnsform, const Ref<PropData2D> &prop);
PropInstance(); PropInstance2D();
~PropInstance(); ~PropInstance2D();
protected: protected:
void _notification(int p_what); void _notification(int p_what);
static void _bind_methods(); static void _bind_methods();
protected: protected:
Ref<PropData> _prop_data; Ref<PropData2D> _prop_data;
Ref<Material> _material; Ref<Material> _material;
uint32_t _collision_layer; uint32_t _collision_layer;

140
prop_instance_job_2d.cpp
View File

@ -28,47 +28,47 @@ SOFTWARE.
#include "../opensimplex/open_simplex_noise.h" #include "../opensimplex/open_simplex_noise.h"
const String PropInstanceJob::BINDING_STRING_ACTIVE_BUILD_PHASE_TYPE = "Normal,Process,Physics Process"; const String PropInstanceJob2D::BINDING_STRING_ACTIVE_BUILD_PHASE_TYPE = "Normal,Process,Physics Process";
PropInstanceJob::ActiveBuildPhaseType PropInstanceJob::get_build_phase_type() { PropInstanceJob2D::ActiveBuildPhaseType PropInstanceJob2D::get_build_phase_type() {
return _build_phase_type; return _build_phase_type;
} }
void PropInstanceJob::set_build_phase_type(PropInstanceJob::ActiveBuildPhaseType build_phase_type) { void PropInstanceJob2D::set_build_phase_type(PropInstanceJob2D::ActiveBuildPhaseType build_phase_type) {
_build_phase_type = build_phase_type; _build_phase_type = build_phase_type;
} }
void PropInstanceJob::set_prop(const Ref<PropData> &prop) { void PropInstanceJob2D::set_prop(const Ref<PropData2D> &prop) {
_prop = prop; _prop = prop;
_in_tree = true; _in_tree = true;
} }
void PropInstanceJob::set_prop_instance(PropInstance *instance) { void PropInstanceJob2D::set_prop_instance(PropInstance2D *instance) {
_instance = instance; _instance = instance;
} }
void PropInstanceJob::set_prop_instance_bind(Node *instance) { void PropInstanceJob2D::set_prop_instance_bind(Node *instance) {
set_prop_instance(Object::cast_to<PropInstance>(instance)); set_prop_instance(Object::cast_to<PropInstance2D>(instance));
} }
int PropInstanceJob::get_phase() { int PropInstanceJob2D::get_phase() {
return _phase; return _phase;
} }
void PropInstanceJob::set_phase(const int phase) { void PropInstanceJob2D::set_phase(const int phase) {
_phase = phase; _phase = phase;
} }
void PropInstanceJob::next_phase() { void PropInstanceJob2D::next_phase() {
++_phase; ++_phase;
} }
bool PropInstanceJob::get_build_done() { bool PropInstanceJob2D::get_build_done() {
return _build_done; return _build_done;
} }
void PropInstanceJob::set_build_done(const bool val) { void PropInstanceJob2D::set_build_done(const bool val) {
_build_done = val; _build_done = val;
} }
void PropInstanceJob::finished() { void PropInstanceJob2D::finished() {
set_build_done(true); set_build_done(true);
if (_instance) { if (_instance) {
@ -76,15 +76,15 @@ void PropInstanceJob::finished() {
} }
} }
void PropInstanceJob::reset() { void PropInstanceJob2D::reset() {
call("_reset"); call("_reset");
} }
void PropInstanceJob::_reset() { void PropInstanceJob2D::_reset() {
_build_done = false; _build_done = false;
_phase = 0; _phase = 0;
} }
void PropInstanceJob::_execute() { void PropInstanceJob2D::_execute() {
ActiveBuildPhaseType origpt = _build_phase_type; ActiveBuildPhaseType origpt = _build_phase_type;
while (!get_cancelled() && _in_tree && !_build_done && origpt == _build_phase_type && !should_return()) { while (!get_cancelled() && _in_tree && !_build_done && origpt == _build_phase_type && !should_return()) {
@ -92,28 +92,28 @@ void PropInstanceJob::_execute() {
} }
} }
void PropInstanceJob::execute_phase() { void PropInstanceJob2D::execute_phase() {
call("_execute_phase"); call("_execute_phase");
} }
void PropInstanceJob::_execute_phase() { void PropInstanceJob2D::_execute_phase() {
finished(); finished();
} }
void PropInstanceJob::process(const float delta) { void PropInstanceJob2D::process(const float delta) {
if (has_method("_process")) if (has_method("_process"))
call("_process", delta); call("_process", delta);
} }
void PropInstanceJob::physics_process(const float delta) { void PropInstanceJob2D::physics_process(const float delta) {
if (has_method("_physics_process")) if (has_method("_physics_process"))
call("_physics_process", delta); call("_physics_process", delta);
} }
void PropInstanceJob::prop_instance_enter_tree() { void PropInstanceJob2D::prop_instance_enter_tree() {
_in_tree = true; _in_tree = true;
} }
void PropInstanceJob::prop_instance_exit_tree() { void PropInstanceJob2D::prop_instance_exit_tree() {
_in_tree = false; _in_tree = false;
if (get_complete()) { if (get_complete()) {
@ -123,7 +123,7 @@ void PropInstanceJob::prop_instance_exit_tree() {
} }
} }
PropInstanceJob::PropInstanceJob() { PropInstanceJob2D::PropInstanceJob2D() {
_instance = NULL; _instance = NULL;
_in_tree = false; _in_tree = false;
@ -143,137 +143,137 @@ PropInstanceJob::PropInstanceJob() {
#endif #endif
} }
PropInstanceJob::~PropInstanceJob() { PropInstanceJob2D::~PropInstanceJob2D() {
_prop.unref(); _prop.unref();
_instance = NULL; _instance = NULL;
} }
void PropInstanceJob::_bind_methods() { void PropInstanceJob2D::_bind_methods() {
BIND_VMETHOD(MethodInfo("_process", PropertyInfo(Variant::REAL, "delta"))); BIND_VMETHOD(MethodInfo("_process", PropertyInfo(Variant::REAL, "delta")));
BIND_VMETHOD(MethodInfo("_physics_process", PropertyInfo(Variant::REAL, "delta"))); BIND_VMETHOD(MethodInfo("_physics_process", PropertyInfo(Variant::REAL, "delta")));
ClassDB::bind_method(D_METHOD("get_build_phase_type"), &PropInstanceJob::get_build_phase_type); ClassDB::bind_method(D_METHOD("get_build_phase_type"), &PropInstanceJob2D::get_build_phase_type);
ClassDB::bind_method(D_METHOD("set_build_phase_type", "value"), &PropInstanceJob::set_build_phase_type); ClassDB::bind_method(D_METHOD("set_build_phase_type", "value"), &PropInstanceJob2D::set_build_phase_type);
ADD_PROPERTY(PropertyInfo(Variant::INT, "build_phase_type", PROPERTY_HINT_ENUM, BINDING_STRING_ACTIVE_BUILD_PHASE_TYPE), "set_build_phase_type", "get_build_phase_type"); ADD_PROPERTY(PropertyInfo(Variant::INT, "build_phase_type", PROPERTY_HINT_ENUM, BINDING_STRING_ACTIVE_BUILD_PHASE_TYPE), "set_build_phase_type", "get_build_phase_type");
ClassDB::bind_method(D_METHOD("set_prop", "prop"), &PropInstanceJob::set_prop); ClassDB::bind_method(D_METHOD("set_prop", "prop"), &PropInstanceJob2D::set_prop);
ClassDB::bind_method(D_METHOD("set_prop_instance", "instance"), &PropInstanceJob::set_prop_instance_bind); ClassDB::bind_method(D_METHOD("set_prop_instance", "instance"), &PropInstanceJob2D::set_prop_instance_bind);
ClassDB::bind_method(D_METHOD("get_phase"), &PropInstanceJob::get_phase); ClassDB::bind_method(D_METHOD("get_phase"), &PropInstanceJob2D::get_phase);
ClassDB::bind_method(D_METHOD("set_phase", "phase"), &PropInstanceJob::set_phase); ClassDB::bind_method(D_METHOD("set_phase", "phase"), &PropInstanceJob2D::set_phase);
ClassDB::bind_method(D_METHOD("next_phase"), &PropInstanceJob::next_phase); ClassDB::bind_method(D_METHOD("next_phase"), &PropInstanceJob2D::next_phase);
ClassDB::bind_method(D_METHOD("get_build_done"), &PropInstanceJob::get_build_done); ClassDB::bind_method(D_METHOD("get_build_done"), &PropInstanceJob2D::get_build_done);
ClassDB::bind_method(D_METHOD("set_build_done", "val"), &PropInstanceJob::set_build_done); ClassDB::bind_method(D_METHOD("set_build_done", "val"), &PropInstanceJob2D::set_build_done);
ClassDB::bind_method(D_METHOD("finished"), &PropInstanceJob::finished); ClassDB::bind_method(D_METHOD("finished"), &PropInstanceJob2D::finished);
BIND_VMETHOD(MethodInfo("_reset")); BIND_VMETHOD(MethodInfo("_reset"));
ClassDB::bind_method(D_METHOD("reset"), &PropInstanceJob::reset); ClassDB::bind_method(D_METHOD("reset"), &PropInstanceJob2D::reset);
ClassDB::bind_method(D_METHOD("_reset"), &PropInstanceJob::_reset); ClassDB::bind_method(D_METHOD("_reset"), &PropInstanceJob2D::_reset);
ClassDB::bind_method(D_METHOD("_execute"), &PropInstanceJob::_execute); ClassDB::bind_method(D_METHOD("_execute"), &PropInstanceJob2D::_execute);
BIND_VMETHOD(MethodInfo("_execute_phase")); BIND_VMETHOD(MethodInfo("_execute_phase"));
ClassDB::bind_method(D_METHOD("execute_phase"), &PropInstanceJob::execute_phase); ClassDB::bind_method(D_METHOD("execute_phase"), &PropInstanceJob2D::execute_phase);
ClassDB::bind_method(D_METHOD("_execute_phase"), &PropInstanceJob::_execute_phase); ClassDB::bind_method(D_METHOD("_execute_phase"), &PropInstanceJob2D::_execute_phase);
ClassDB::bind_method(D_METHOD("prop_instance_exit_tree"), &PropInstanceJob::prop_instance_exit_tree); ClassDB::bind_method(D_METHOD("prop_instance_exit_tree"), &PropInstanceJob2D::prop_instance_exit_tree);
#if !THREAD_POOL_PRESENT #if !THREAD_POOL_PRESENT
ClassDB::bind_method(D_METHOD("get_complete"), &PropInstanceJob::get_complete); ClassDB::bind_method(D_METHOD("get_complete"), &PropInstanceJob2D::get_complete);
ClassDB::bind_method(D_METHOD("set_complete", "value"), &PropInstanceJob::set_complete); ClassDB::bind_method(D_METHOD("set_complete", "value"), &PropInstanceJob2D::set_complete);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "complete"), "set_complete", "get_complete"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "complete"), "set_complete", "get_complete");
ClassDB::bind_method(D_METHOD("get_start_time"), &PropInstanceJob::get_start_time); ClassDB::bind_method(D_METHOD("get_start_time"), &PropInstanceJob2D::get_start_time);
ClassDB::bind_method(D_METHOD("set_start_time", "value"), &PropInstanceJob::set_start_time); ClassDB::bind_method(D_METHOD("set_start_time", "value"), &PropInstanceJob2D::set_start_time);
ADD_PROPERTY(PropertyInfo(Variant::INT, "start_time"), "set_start_time", "get_start_time"); ADD_PROPERTY(PropertyInfo(Variant::INT, "start_time"), "set_start_time", "get_start_time");
ClassDB::bind_method(D_METHOD("get_current_run_stage"), &PropInstanceJob::get_current_run_stage); ClassDB::bind_method(D_METHOD("get_current_run_stage"), &PropInstanceJob2D::get_current_run_stage);
ClassDB::bind_method(D_METHOD("set_current_run_stage", "value"), &PropInstanceJob::set_current_run_stage); ClassDB::bind_method(D_METHOD("set_current_run_stage", "value"), &PropInstanceJob2D::set_current_run_stage);
ADD_PROPERTY(PropertyInfo(Variant::INT, "current_run_stage"), "set_current_run_stage", "get_current_run_stage"); ADD_PROPERTY(PropertyInfo(Variant::INT, "current_run_stage"), "set_current_run_stage", "get_current_run_stage");
ClassDB::bind_method(D_METHOD("get_stage"), &PropInstanceJob::get_stage); ClassDB::bind_method(D_METHOD("get_stage"), &PropInstanceJob2D::get_stage);
ClassDB::bind_method(D_METHOD("set_stage", "value"), &PropInstanceJob::set_stage); ClassDB::bind_method(D_METHOD("set_stage", "value"), &PropInstanceJob2D::set_stage);
ADD_PROPERTY(PropertyInfo(Variant::INT, "stage"), "set_stage", "get_stage"); ADD_PROPERTY(PropertyInfo(Variant::INT, "stage"), "set_stage", "get_stage");
ClassDB::bind_method(D_METHOD("get_current_execution_time"), &PropInstanceJob::get_current_execution_time); ClassDB::bind_method(D_METHOD("get_current_execution_time"), &PropInstanceJob2D::get_current_execution_time);
ClassDB::bind_method(D_METHOD("should_do", "just_check"), &PropInstanceJob::should_do, DEFVAL(false)); ClassDB::bind_method(D_METHOD("should_do", "just_check"), &PropInstanceJob2D::should_do, DEFVAL(false));
ClassDB::bind_method(D_METHOD("should_return"), &PropInstanceJob::should_return); ClassDB::bind_method(D_METHOD("should_return"), &PropInstanceJob2D::should_return);
BIND_VMETHOD(MethodInfo("_execute")); BIND_VMETHOD(MethodInfo("_execute"));
ClassDB::bind_method(D_METHOD("execute"), &PropInstanceJob::execute); ClassDB::bind_method(D_METHOD("execute"), &PropInstanceJob2D::execute);
ADD_SIGNAL(MethodInfo("completed")); ADD_SIGNAL(MethodInfo("completed"));
#endif #endif
} }
#if !THREAD_POOL_PRESENT #if !THREAD_POOL_PRESENT
bool PropInstanceJob::get_complete() const { bool PropInstanceJob2D::get_complete() const {
return _complete; return _complete;
} }
void PropInstanceJob::set_complete(const bool value) { void PropInstanceJob2D::set_complete(const bool value) {
_complete = value; _complete = value;
} }
bool PropInstanceJob::get_cancelled() const { bool PropInstanceJob2D::get_cancelled() const {
return _cancelled; return _cancelled;
} }
void PropInstanceJob::set_cancelled(const bool value) { void PropInstanceJob2D::set_cancelled(const bool value) {
_cancelled = value; _cancelled = value;
} }
float PropInstanceJob::get_max_allocated_time() const { float PropInstanceJob2D::get_max_allocated_time() const {
return _max_allocated_time; return _max_allocated_time;
} }
void PropInstanceJob::set_max_allocated_time(const float value) { void PropInstanceJob2D::set_max_allocated_time(const float value) {
_max_allocated_time = value; _max_allocated_time = value;
} }
int PropInstanceJob::get_start_time() const { int PropInstanceJob2D::get_start_time() const {
return _start_time; return _start_time;
} }
void PropInstanceJob::set_start_time(const int value) { void PropInstanceJob2D::set_start_time(const int value) {
_start_time = value; _start_time = value;
} }
int PropInstanceJob::get_current_run_stage() const { int PropInstanceJob2D::get_current_run_stage() const {
return _current_run_stage; return _current_run_stage;
} }
void PropInstanceJob::set_current_run_stage(const int value) { void PropInstanceJob2D::set_current_run_stage(const int value) {
_current_run_stage = value; _current_run_stage = value;
} }
int PropInstanceJob::get_stage() const { int PropInstanceJob2D::get_stage() const {
return _stage; return _stage;
} }
void PropInstanceJob::set_stage(const int value) { void PropInstanceJob2D::set_stage(const int value) {
_stage = value; _stage = value;
} }
void PropInstanceJob::reset_stages() { void PropInstanceJob2D::reset_stages() {
_current_run_stage = 0; _current_run_stage = 0;
_stage = 0; _stage = 0;
} }
float PropInstanceJob::get_current_execution_time() { float PropInstanceJob2D::get_current_execution_time() {
return 0; return 0;
} }
bool PropInstanceJob::should_do(const bool just_check) { bool PropInstanceJob2D::should_do(const bool just_check) {
return true; return true;
} }
bool PropInstanceJob::should_return() { bool PropInstanceJob2D::should_return() {
if (_cancelled) if (_cancelled)
return true; return true;
return false; return false;
} }
void PropInstanceJob::execute() { void PropInstanceJob2D::execute() {
ERR_FAIL_COND(!has_method("_execute")); ERR_FAIL_COND(!has_method("_execute"));
call("_execute"); call("_execute");

28
prop_instance_job_2d.h
View File

@ -40,15 +40,15 @@ SOFTWARE.
#endif #endif
class PropData; class PropData2D;
class PropInstance; class PropInstance2D;
#if THREAD_POOL_PRESENT #if THREAD_POOL_PRESENT
class PropInstanceJob : public ThreadPoolJob { class PropInstanceJob2D : public ThreadPoolJob {
GDCLASS(PropInstanceJob, ThreadPoolJob); GDCLASS(PropInstanceJob2D, ThreadPoolJob);
#else #else
class PropInstanceJob : public Reference { class PropInstanceJob2D : public Reference {
GDCLASS(PropInstanceJob, Reference); GDCLASS(PropInstanceJob2D, Reference);
#endif #endif
public: public:
@ -62,10 +62,10 @@ public:
public: public:
ActiveBuildPhaseType get_build_phase_type(); ActiveBuildPhaseType get_build_phase_type();
void set_build_phase_type(PropInstanceJob::ActiveBuildPhaseType build_phase_type); void set_build_phase_type(PropInstanceJob2D::ActiveBuildPhaseType build_phase_type);
void set_prop(const Ref<PropData> &prop); void set_prop(const Ref<PropData2D> &prop);
void set_prop_instance(PropInstance *instance); void set_prop_instance(PropInstance2D *instance);
void set_prop_instance_bind(Node *instance); void set_prop_instance_bind(Node *instance);
int get_phase(); int get_phase();
@ -91,8 +91,8 @@ public:
void prop_instance_enter_tree(); void prop_instance_enter_tree();
void prop_instance_exit_tree(); void prop_instance_exit_tree();
PropInstanceJob(); PropInstanceJob2D();
~PropInstanceJob(); ~PropInstanceJob2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();
@ -101,8 +101,8 @@ protected:
bool _build_done; bool _build_done;
int _phase; int _phase;
bool _in_tree; bool _in_tree;
Ref<PropData> _prop; Ref<PropData2D> _prop;
PropInstance *_instance; PropInstance2D *_instance;
public: public:
#if !THREAD_POOL_PRESENT #if !THREAD_POOL_PRESENT
@ -145,6 +145,6 @@ private:
#endif #endif
}; };
VARIANT_ENUM_CAST(PropInstanceJob::ActiveBuildPhaseType); VARIANT_ENUM_CAST(PropInstanceJob2D::ActiveBuildPhaseType);
#endif #endif

242
prop_instance_merger_2d.cpp
View File

@ -67,12 +67,12 @@ typedef class RenderingServer VS;
#include "scene/resources/box_shape.h" #include "scene/resources/box_shape.h"
const float PropInstanceMerger::LOD_CHECK_INTERVAL = 2; const float PropInstanceMerger2D::LOD_CHECK_INTERVAL = 2;
bool PropInstanceMerger::get_building() { bool PropInstanceMerger2D::get_building() {
return _building; return _building;
} }
void PropInstanceMerger::set_building(const bool value) { void PropInstanceMerger2D::set_building(const bool value) {
_building = value; _building = value;
set_physics_process_internal(_building); set_physics_process_internal(_building);
@ -82,10 +82,10 @@ void PropInstanceMerger::set_building(const bool value) {
} }
} }
int PropInstanceMerger::get_lod_level() { int PropInstanceMerger2D::get_lod_level() {
return _lod_level; return _lod_level;
} }
void PropInstanceMerger::set_lod_level(const int value) { void PropInstanceMerger2D::set_lod_level(const int value) {
_lod_level = value; _lod_level = value;
if (_lod_level < 0) { if (_lod_level < 0) {
@ -95,62 +95,62 @@ void PropInstanceMerger::set_lod_level(const int value) {
apply_lod_level(); apply_lod_level();
} }
bool PropInstanceMerger::get_auto_lod() { bool PropInstanceMerger2D::get_auto_lod() {
return _auto_lod; return _auto_lod;
} }
void PropInstanceMerger::set_auto_lod(const bool value) { void PropInstanceMerger2D::set_auto_lod(const bool value) {
_auto_lod = value; _auto_lod = value;
check_auto_lod(); check_auto_lod();
} }
float PropInstanceMerger::get_first_lod_distance_squared() { float PropInstanceMerger2D::get_first_lod_distance_squared() {
return _first_lod_distance_squared; return _first_lod_distance_squared;
} }
void PropInstanceMerger::set_first_lod_distance_squared(const float dist) { void PropInstanceMerger2D::set_first_lod_distance_squared(const float dist) {
_first_lod_distance_squared = dist; _first_lod_distance_squared = dist;
} }
float PropInstanceMerger::get_lod_reduction_distance_squared() { float PropInstanceMerger2D::get_lod_reduction_distance_squared() {
return _lod_reduction_distance_squared; return _lod_reduction_distance_squared;
} }
void PropInstanceMerger::set_lod_reduction_distance_squared(const float dist) { void PropInstanceMerger2D::set_lod_reduction_distance_squared(const float dist) {
_lod_reduction_distance_squared = dist; _lod_reduction_distance_squared = dist;
} }
Ref<PropInstanceJob> PropInstanceMerger::get_job() { Ref<PropInstanceJob2D> PropInstanceMerger2D::get_job() {
return _job; return _job;
} }
void PropInstanceMerger::set_job(const Ref<PropInstanceJob> &job) { void PropInstanceMerger2D::set_job(const Ref<PropInstanceJob2D> &job) {
_job = job; _job = job;
} }
//Materials //Materials
Ref<Material> PropInstanceMerger::material_get(const int index) { Ref<Material> PropInstanceMerger2D::material_get(const int index) {
ERR_FAIL_INDEX_V(index, _materials.size(), Ref<Material>(NULL)); ERR_FAIL_INDEX_V(index, _materials.size(), Ref<Material>(NULL));
return _materials[index]; return _materials[index];
} }
void PropInstanceMerger::material_add(const Ref<Material> &value) { void PropInstanceMerger2D::material_add(const Ref<Material> &value) {
ERR_FAIL_COND(!value.is_valid()); ERR_FAIL_COND(!value.is_valid());
_materials.push_back(value); _materials.push_back(value);
} }
int PropInstanceMerger::material_get_num() const { int PropInstanceMerger2D::material_get_num() const {
return _materials.size(); return _materials.size();
} }
void PropInstanceMerger::materials_clear() { void PropInstanceMerger2D::materials_clear() {
_materials.clear(); _materials.clear();
} }
Vector<Variant> PropInstanceMerger::materials_get() { Vector<Variant> PropInstanceMerger2D::materials_get() {
VARIANT_ARRAY_GET(_materials); VARIANT_ARRAY_GET(_materials);
} }
void PropInstanceMerger::materials_set(const Vector<Variant> &materials) { void PropInstanceMerger2D::materials_set(const Vector<Variant> &materials) {
_materials.clear(); _materials.clear();
for (int i = 0; i < materials.size(); i++) { for (int i = 0; i < materials.size(); i++) {
@ -161,19 +161,19 @@ void PropInstanceMerger::materials_set(const Vector<Variant> &materials) {
} }
//Meshes //Meshes
RID PropInstanceMerger::mesh_get(const int index) { RID PropInstanceMerger2D::mesh_get(const int index) {
ERR_FAIL_INDEX_V(index, _meshes.size(), RID()); ERR_FAIL_INDEX_V(index, _meshes.size(), RID());
return _meshes[index].mesh; return _meshes[index].mesh;
} }
RID PropInstanceMerger::mesh_instance_get(const int index) { RID PropInstanceMerger2D::mesh_instance_get(const int index) {
ERR_FAIL_INDEX_V(index, _meshes.size(), RID()); ERR_FAIL_INDEX_V(index, _meshes.size(), RID());
return _meshes[index].mesh_instance; return _meshes[index].mesh_instance;
} }
void PropInstanceMerger::mesh_add(const RID mesh_instance, const RID mesh) { void PropInstanceMerger2D::mesh_add(const RID mesh_instance, const RID mesh) {
MeshEntry e; MeshEntry e;
e.mesh = mesh; e.mesh = mesh;
e.mesh_instance = mesh_instance; e.mesh_instance = mesh_instance;
@ -181,15 +181,15 @@ void PropInstanceMerger::mesh_add(const RID mesh_instance, const RID mesh) {
_meshes.push_back(e); _meshes.push_back(e);
} }
int PropInstanceMerger::mesh_get_num() const { int PropInstanceMerger2D::mesh_get_num() const {
return _meshes.size(); return _meshes.size();
} }
void PropInstanceMerger::meshes_clear() { void PropInstanceMerger2D::meshes_clear() {
_meshes.clear(); _meshes.clear();
} }
void PropInstanceMerger::meshes_create(const int num) { void PropInstanceMerger2D::meshes_create(const int num) {
free_meshes(); free_meshes();
for (int i = 0; i < num; ++i) { for (int i = 0; i < num; ++i) {
@ -216,7 +216,7 @@ void PropInstanceMerger::meshes_create(const int num) {
apply_lod_level(); apply_lod_level();
} }
Vector<Variant> PropInstanceMerger::meshes_get() { Vector<Variant> PropInstanceMerger2D::meshes_get() {
Vector<Variant> r; Vector<Variant> r;
for (int i = 0; i < _meshes.size(); i++) { for (int i = 0; i < _meshes.size(); i++) {
Array a; Array a;
@ -229,7 +229,7 @@ Vector<Variant> PropInstanceMerger::meshes_get() {
return r; return r;
} }
void PropInstanceMerger::meshes_set(const Vector<Variant> &meshs) { void PropInstanceMerger2D::meshes_set(const Vector<Variant> &meshs) {
_meshes.clear(); _meshes.clear();
for (int i = 0; i < _meshes.size(); i++) { for (int i = 0; i < _meshes.size(); i++) {
@ -247,31 +247,31 @@ void PropInstanceMerger::meshes_set(const Vector<Variant> &meshs) {
//Collider //Collider
Transform PropInstanceMerger::collider_local_transform_get(const int index) { Transform PropInstanceMerger2D::collider_local_transform_get(const int index) {
ERR_FAIL_INDEX_V(index, _colliders.size(), Transform()); ERR_FAIL_INDEX_V(index, _colliders.size(), Transform());
return _colliders[index].transform; return _colliders[index].transform;
} }
RID PropInstanceMerger::collider_body_get(const int index) { RID PropInstanceMerger2D::collider_body_get(const int index) {
ERR_FAIL_INDEX_V(index, _colliders.size(), RID()); ERR_FAIL_INDEX_V(index, _colliders.size(), RID());
return _colliders[index].body; return _colliders[index].body;
} }
Ref<Shape> PropInstanceMerger::collider_shape_get(const int index) { Ref<Shape> PropInstanceMerger2D::collider_shape_get(const int index) {
ERR_FAIL_INDEX_V(index, _colliders.size(), Ref<Shape>()); ERR_FAIL_INDEX_V(index, _colliders.size(), Ref<Shape>());
return _colliders[index].shape; return _colliders[index].shape;
} }
RID PropInstanceMerger::collider_shape_rid_get(const int index) { RID PropInstanceMerger2D::collider_shape_rid_get(const int index) {
ERR_FAIL_INDEX_V(index, _colliders.size(), RID()); ERR_FAIL_INDEX_V(index, _colliders.size(), RID());
return _colliders[index].shape_rid; return _colliders[index].shape_rid;
} }
int PropInstanceMerger::collider_add(const Transform &local_transform, const Ref<Shape> &shape, const RID &shape_rid, const RID &body, const bool owns_shape) { int PropInstanceMerger2D::collider_add(const Transform &local_transform, const Ref<Shape> &shape, const RID &shape_rid, const RID &body, const bool owns_shape) {
ERR_FAIL_COND_V(!shape.is_valid() && shape_rid == RID(), 0); ERR_FAIL_COND_V(!shape.is_valid() && shape_rid == RID(), 0);
int index = _colliders.size(); int index = _colliders.size();
@ -288,15 +288,15 @@ int PropInstanceMerger::collider_add(const Transform &local_transform, const Ref
return index; return index;
} }
int PropInstanceMerger::collider_get_num() const { int PropInstanceMerger2D::collider_get_num() const {
return _colliders.size(); return _colliders.size();
} }
void PropInstanceMerger::colliders_clear() { void PropInstanceMerger2D::colliders_clear() {
_colliders.clear(); _colliders.clear();
} }
Vector<Variant> PropInstanceMerger::colliders_get() { Vector<Variant> PropInstanceMerger2D::colliders_get() {
Vector<Variant> r; Vector<Variant> r;
for (int i = 0; i < _colliders.size(); i++) { for (int i = 0; i < _colliders.size(); i++) {
r.push_back(_colliders[i].body); r.push_back(_colliders[i].body);
@ -304,7 +304,7 @@ Vector<Variant> PropInstanceMerger::colliders_get() {
return r; return r;
} }
void PropInstanceMerger::colliders_set(const Vector<Variant> &colliders) { void PropInstanceMerger2D::colliders_set(const Vector<Variant> &colliders) {
_colliders.clear(); _colliders.clear();
for (int i = 0; i < colliders.size(); i++) { for (int i = 0; i < colliders.size(); i++) {
@ -317,7 +317,7 @@ void PropInstanceMerger::colliders_set(const Vector<Variant> &colliders) {
} }
} }
void PropInstanceMerger::check_auto_lod() { void PropInstanceMerger2D::check_auto_lod() {
if (!_auto_lod) { if (!_auto_lod) {
_auto_lod_on = false; _auto_lod_on = false;
return; return;
@ -337,7 +337,7 @@ void PropInstanceMerger::check_auto_lod() {
set_process_internal(true); set_process_internal(true);
} }
void PropInstanceMerger::apply_lod_level() { void PropInstanceMerger2D::apply_lod_level() {
if (_meshes.size() == 0) { if (_meshes.size() == 0) {
return; return;
} }
@ -377,7 +377,7 @@ void PropInstanceMerger::apply_lod_level() {
vs->instance_set_visible(mi, true); vs->instance_set_visible(mi, true);
} }
void PropInstanceMerger::debug_mesh_allocate() { void PropInstanceMerger2D::debug_mesh_allocate() {
if (_debug_mesh_rid == RID()) { if (_debug_mesh_rid == RID()) {
_debug_mesh_rid = VisualServer::get_singleton()->mesh_create(); _debug_mesh_rid = VisualServer::get_singleton()->mesh_create();
} }
@ -393,7 +393,7 @@ void PropInstanceMerger::debug_mesh_allocate() {
VS::get_singleton()->instance_set_visible(_debug_mesh_instance, true); VS::get_singleton()->instance_set_visible(_debug_mesh_instance, true);
} }
} }
void PropInstanceMerger::debug_mesh_free() { void PropInstanceMerger2D::debug_mesh_free() {
if (_debug_mesh_instance != RID()) { if (_debug_mesh_instance != RID()) {
VisualServer::get_singleton()->free(_debug_mesh_instance); VisualServer::get_singleton()->free(_debug_mesh_instance);
} }
@ -402,25 +402,25 @@ void PropInstanceMerger::debug_mesh_free() {
VisualServer::get_singleton()->free(_debug_mesh_rid); VisualServer::get_singleton()->free(_debug_mesh_rid);
} }
} }
bool PropInstanceMerger::debug_mesh_has() { bool PropInstanceMerger2D::debug_mesh_has() {
return _debug_mesh_rid != RID(); return _debug_mesh_rid != RID();
} }
void PropInstanceMerger::debug_mesh_clear() { void PropInstanceMerger2D::debug_mesh_clear() {
if (_debug_mesh_rid != RID()) { if (_debug_mesh_rid != RID()) {
VisualServer::get_singleton()->mesh_clear(_debug_mesh_rid); VisualServer::get_singleton()->mesh_clear(_debug_mesh_rid);
} }
} }
void PropInstanceMerger::debug_mesh_array_clear() { void PropInstanceMerger2D::debug_mesh_array_clear() {
_debug_mesh_array.resize(0); _debug_mesh_array.resize(0);
} }
void PropInstanceMerger::debug_mesh_add_vertices_to(const PoolVector3Array &arr) { void PropInstanceMerger2D::debug_mesh_add_vertices_to(const PoolVector3Array &arr) {
_debug_mesh_array.append_array(arr); _debug_mesh_array.append_array(arr);
if (_debug_mesh_array.size() % 2 == 1) { if (_debug_mesh_array.size() % 2 == 1) {
_debug_mesh_array.append(_debug_mesh_array[_debug_mesh_array.size() - 1]); _debug_mesh_array.append(_debug_mesh_array[_debug_mesh_array.size() - 1]);
} }
} }
void PropInstanceMerger::debug_mesh_send() { void PropInstanceMerger2D::debug_mesh_send() {
debug_mesh_allocate(); debug_mesh_allocate();
debug_mesh_clear(); debug_mesh_clear();
@ -442,7 +442,7 @@ void PropInstanceMerger::debug_mesh_send() {
debug_mesh_array_clear(); debug_mesh_array_clear();
} }
void PropInstanceMerger::draw_debug_mdr_colliders() { void PropInstanceMerger2D::draw_debug_mdr_colliders() {
if (!debug_mesh_has()) { if (!debug_mesh_has()) {
debug_mesh_allocate(); debug_mesh_allocate();
} }
@ -462,7 +462,7 @@ void PropInstanceMerger::draw_debug_mdr_colliders() {
debug_mesh_send(); debug_mesh_send();
} }
void PropInstanceMerger::free_meshes() { void PropInstanceMerger2D::free_meshes() {
RID rid; RID rid;
for (int i = 0; i < _meshes.size(); ++i) { for (int i = 0; i < _meshes.size(); ++i) {
@ -481,7 +481,7 @@ void PropInstanceMerger::free_meshes() {
} }
} }
void PropInstanceMerger::free_colliders() { void PropInstanceMerger2D::free_colliders() {
for (int i = 0; i < _colliders.size(); ++i) { for (int i = 0; i < _colliders.size(); ++i) {
ColliderBody &e = _colliders.write[i]; ColliderBody &e = _colliders.write[i];
@ -496,10 +496,10 @@ void PropInstanceMerger::free_colliders() {
} }
} }
void PropInstanceMerger::_init_materials() { void PropInstanceMerger2D::_init_materials() {
} }
void PropInstanceMerger::_build() { void PropInstanceMerger2D::_build() {
if (_building) { if (_building) {
return; return;
} }
@ -541,7 +541,7 @@ void PropInstanceMerger::_build() {
_job->reset(); _job->reset();
_job->set_complete(false); _job->set_complete(false);
Ref<PropMaterialCache> cache = PropCache::get_singleton()->material_cache_get(_prop_data); Ref<PropMaterialCache2D> cache = PropCache2D::get_singleton()->material_cache_get(_prop_data);
if (cache->material_get_num() == 0) { if (cache->material_get_num() == 0) {
//lock it! //lock it!
@ -574,7 +574,7 @@ Don't submit here, as it starts in physics process mode
*/ */
} }
void PropInstanceMerger::_build_finished() { void PropInstanceMerger2D::_build_finished() {
set_building(false); set_building(false);
apply_lod_level(); apply_lod_level();
@ -587,22 +587,22 @@ void PropInstanceMerger::_build_finished() {
} }
} }
void PropInstanceMerger::_prop_preprocess(Transform transform, const Ref<PropData> &prop) { void PropInstanceMerger2D::_prop_preprocess(Transform transform, const Ref<PropData2D> &prop) {
ERR_FAIL_COND(!prop.is_valid()); ERR_FAIL_COND(!prop.is_valid());
int count = prop->get_prop_count(); int count = prop->get_prop_count();
for (int i = 0; i < count; ++i) { for (int i = 0; i < count; ++i) {
Ref<PropDataEntry> e = prop->get_prop(i); Ref<PropDataEntry2D> e = prop->get_prop(i);
if (!e.is_valid()) if (!e.is_valid())
continue; continue;
Transform t = transform * e->get_transform(); Transform t = transform * e->get_transform();
Ref<PropDataProp> prop_entry_data = e; Ref<PropDataProp2D> prop_entry_data = e;
if (prop_entry_data.is_valid()) { if (prop_entry_data.is_valid()) {
Ref<PropData> p = prop_entry_data->get_prop(); Ref<PropData2D> p = prop_entry_data->get_prop();
if (!p.is_valid()) if (!p.is_valid())
continue; continue;
@ -612,7 +612,7 @@ void PropInstanceMerger::_prop_preprocess(Transform transform, const Ref<PropDat
continue; continue;
} }
Ref<PropDataTiledWall> tiled_wall_data = e; Ref<PropDataTiledWall2D> tiled_wall_data = e;
if (tiled_wall_data.is_valid()) { if (tiled_wall_data.is_valid()) {
_job->add_tiled_wall(tiled_wall_data, t); _job->add_tiled_wall(tiled_wall_data, t);
@ -636,7 +636,7 @@ void PropInstanceMerger::_prop_preprocess(Transform transform, const Ref<PropDat
continue; continue;
} }
Ref<PropDataScene> scene_data = e; Ref<PropDataScene2D> scene_data = e;
if (scene_data.is_valid()) { if (scene_data.is_valid()) {
Ref<PackedScene> sc = scene_data->get_scene(); Ref<PackedScene> sc = scene_data->get_scene();
@ -658,11 +658,11 @@ void PropInstanceMerger::_prop_preprocess(Transform transform, const Ref<PropDat
} }
//Will create a Terralight node, and prop //Will create a Terralight node, and prop
//PropDataLight could use standard godot light nodes //PropData2DLight could use standard godot light nodes
Ref<PropDataLight> light_data = e; Ref<PropDataLight2D> light_data = e;
if (light_data.is_valid()) { if (light_data.is_valid()) {
Ref<PropLight> light; Ref<PropLight2D> light;
light.instance(); light.instance();
Vector3 v = t.xform(Vector3()); Vector3 v = t.xform(Vector3());
@ -677,7 +677,7 @@ void PropInstanceMerger::_prop_preprocess(Transform transform, const Ref<PropDat
} }
#if MESH_DATA_RESOURCE_PRESENT #if MESH_DATA_RESOURCE_PRESENT
Ref<PropDataMeshData> mesh_data = e; Ref<PropDataMeshData2D> mesh_data = e;
if (mesh_data.is_valid()) { if (mesh_data.is_valid()) {
Ref<MeshDataResource> mdr = mesh_data->get_mesh(); Ref<MeshDataResource> mdr = mesh_data->get_mesh();
@ -695,7 +695,7 @@ void PropInstanceMerger::_prop_preprocess(Transform transform, const Ref<PropDat
} }
} }
void PropInstanceMerger::collision_layer_changed() { void PropInstanceMerger2D::collision_layer_changed() {
for (int i = 0; i < _colliders.size(); ++i) { for (int i = 0; i < _colliders.size(); ++i) {
const ColliderBody &c = _colliders[i]; const ColliderBody &c = _colliders[i];
@ -704,7 +704,7 @@ void PropInstanceMerger::collision_layer_changed() {
} }
} }
} }
void PropInstanceMerger::collision_mask_changed() { void PropInstanceMerger2D::collision_mask_changed() {
for (int i = 0; i < _colliders.size(); ++i) { for (int i = 0; i < _colliders.size(); ++i) {
const ColliderBody &c = _colliders[i]; const ColliderBody &c = _colliders[i];
@ -714,7 +714,7 @@ void PropInstanceMerger::collision_mask_changed() {
} }
} }
PropInstanceMerger::PropInstanceMerger() { PropInstanceMerger2D::PropInstanceMerger2D() {
_build_queued = false; _build_queued = false;
_auto_lod = true; _auto_lod = true;
_auto_lod_on = false; _auto_lod_on = false;
@ -731,25 +731,25 @@ PropInstanceMerger::PropInstanceMerger() {
_lod_reduction_distance_squared = 600; _lod_reduction_distance_squared = 600;
//todo this should probably be in a virtual method, like in Terraman or Voxelman //todo this should probably be in a virtual method, like in Terraman or Voxelman
_job = Ref<PropInstancePropJob>(memnew(PropInstancePropJob())); _job = Ref<PropInstancePropJob2D>(memnew(PropInstancePropJob2D()));
_job->set_prop_instace(this); _job->set_prop_instace(this);
Ref<PropMesherJobStep> js; Ref<PropMesherJobStep2D> js;
js.instance(); js.instance();
js->set_job_type(PropMesherJobStep::TYPE_NORMAL); js->set_job_type(PropMesherJobStep2D::TYPE_NORMAL);
_job->add_jobs_step(js); _job->add_jobs_step(js);
js.instance(); js.instance();
js->set_job_type(PropMesherJobStep::TYPE_MERGE_VERTS); js->set_job_type(PropMesherJobStep2D::TYPE_MERGE_VERTS);
_job->add_jobs_step(js); _job->add_jobs_step(js);
js.instance(); js.instance();
js->set_job_type(PropMesherJobStep::TYPE_BAKE_TEXTURE); js->set_job_type(PropMesherJobStep2D::TYPE_BAKE_TEXTURE);
_job->add_jobs_step(js); _job->add_jobs_step(js);
} }
PropInstanceMerger::~PropInstanceMerger() { PropInstanceMerger2D::~PropInstanceMerger2D() {
_job.unref(); _job.unref();
_prop_data.unref(); _prop_data.unref();
@ -757,7 +757,7 @@ PropInstanceMerger::~PropInstanceMerger() {
_materials.clear(); _materials.clear();
} }
void PropInstanceMerger::_notification(int p_what) { void PropInstanceMerger2D::_notification(int p_what) {
switch (p_what) { switch (p_what) {
case NOTIFICATION_ENTER_TREE: { case NOTIFICATION_ENTER_TREE: {
if (_prop_data.is_valid()) { if (_prop_data.is_valid()) {
@ -783,10 +783,10 @@ void PropInstanceMerger::_notification(int p_what) {
return; return;
} }
if (_job->get_build_phase_type() == PropInstanceJob::BUILD_PHASE_TYPE_PHYSICS_PROCESS) { if (_job->get_build_phase_type() == PropInstanceJob2D::BUILD_PHASE_TYPE_PHYSICS_PROCESS) {
_job->physics_process(get_physics_process_delta_time()); _job->physics_process(get_physics_process_delta_time());
if (_job->get_build_phase_type() == PropInstanceJob::BUILD_PHASE_TYPE_NORMAL) { if (_job->get_build_phase_type() == PropInstanceJob2D::BUILD_PHASE_TYPE_NORMAL) {
#if THREAD_POOL_PRESENT #if THREAD_POOL_PRESENT
ThreadPool::get_singleton()->add_job(_job); ThreadPool::get_singleton()->add_job(_job);
#else #else
@ -804,10 +804,10 @@ void PropInstanceMerger::_notification(int p_what) {
return; return;
} }
if (_job->get_build_phase_type() == PropInstanceJob::BUILD_PHASE_TYPE_PROCESS) { if (_job->get_build_phase_type() == PropInstanceJob2D::BUILD_PHASE_TYPE_PROCESS) {
_job->process(get_process_delta_time()); _job->process(get_process_delta_time());
if (_job->get_build_phase_type() == PropInstanceJob::BUILD_PHASE_TYPE_NORMAL) { if (_job->get_build_phase_type() == PropInstanceJob2D::BUILD_PHASE_TYPE_NORMAL) {
#if THREAD_POOL_PRESENT #if THREAD_POOL_PRESENT
ThreadPool::get_singleton()->add_job(_job); ThreadPool::get_singleton()->add_job(_job);
#else #else
@ -909,72 +909,72 @@ void PropInstanceMerger::_notification(int p_what) {
} }
} }
void PropInstanceMerger::_bind_methods() { void PropInstanceMerger2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_job"), &PropInstanceMerger::get_job); ClassDB::bind_method(D_METHOD("get_job"), &PropInstanceMerger2D::get_job);
ClassDB::bind_method(D_METHOD("set_job", "value"), &PropInstanceMerger::set_job); ClassDB::bind_method(D_METHOD("set_job", "value"), &PropInstanceMerger2D::set_job);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "job", PROPERTY_HINT_RESOURCE_TYPE, "PropInstanceJob", 0), "set_job", "get_job"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "job", PROPERTY_HINT_RESOURCE_TYPE, "PropInstanceJob2D", 0), "set_job", "get_job");
ClassDB::bind_method(D_METHOD("get_lod_level"), &PropInstanceMerger::get_lod_level); ClassDB::bind_method(D_METHOD("get_lod_level"), &PropInstanceMerger2D::get_lod_level);
ClassDB::bind_method(D_METHOD("set_lod_level", "value"), &PropInstanceMerger::set_lod_level); ClassDB::bind_method(D_METHOD("set_lod_level", "value"), &PropInstanceMerger2D::set_lod_level);
ADD_PROPERTY(PropertyInfo(Variant::INT, "lod_level"), "set_lod_level", "get_lod_level"); ADD_PROPERTY(PropertyInfo(Variant::INT, "lod_level"), "set_lod_level", "get_lod_level");
ClassDB::bind_method(D_METHOD("get_auto_lod"), &PropInstanceMerger::get_auto_lod); ClassDB::bind_method(D_METHOD("get_auto_lod"), &PropInstanceMerger2D::get_auto_lod);
ClassDB::bind_method(D_METHOD("set_auto_lod", "value"), &PropInstanceMerger::set_auto_lod); ClassDB::bind_method(D_METHOD("set_auto_lod", "value"), &PropInstanceMerger2D::set_auto_lod);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_lod"), "set_auto_lod", "get_auto_lod"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_lod"), "set_auto_lod", "get_auto_lod");
ClassDB::bind_method(D_METHOD("get_first_lod_distance_squared"), &PropInstanceMerger::get_first_lod_distance_squared); ClassDB::bind_method(D_METHOD("get_first_lod_distance_squared"), &PropInstanceMerger2D::get_first_lod_distance_squared);
ClassDB::bind_method(D_METHOD("set_first_lod_distance_squared", "value"), &PropInstanceMerger::set_first_lod_distance_squared); ClassDB::bind_method(D_METHOD("set_first_lod_distance_squared", "value"), &PropInstanceMerger2D::set_first_lod_distance_squared);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "first_lod_distance_squared"), "set_first_lod_distance_squared", "get_first_lod_distance_squared"); ADD_PROPERTY(PropertyInfo(Variant::REAL, "first_lod_distance_squared"), "set_first_lod_distance_squared", "get_first_lod_distance_squared");
ClassDB::bind_method(D_METHOD("get_lod_reduction_distance_squared"), &PropInstanceMerger::get_lod_reduction_distance_squared); ClassDB::bind_method(D_METHOD("get_lod_reduction_distance_squared"), &PropInstanceMerger2D::get_lod_reduction_distance_squared);
ClassDB::bind_method(D_METHOD("set_lod_reduction_distance_squared", "value"), &PropInstanceMerger::set_lod_reduction_distance_squared); ClassDB::bind_method(D_METHOD("set_lod_reduction_distance_squared", "value"), &PropInstanceMerger2D::set_lod_reduction_distance_squared);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "lod_reduction_distance_squared"), "set_lod_reduction_distance_squared", "get_lod_reduction_distance_squared"); ADD_PROPERTY(PropertyInfo(Variant::REAL, "lod_reduction_distance_squared"), "set_lod_reduction_distance_squared", "get_lod_reduction_distance_squared");
///Materials ///Materials
ClassDB::bind_method(D_METHOD("material_get", "index"), &PropInstanceMerger::material_get); ClassDB::bind_method(D_METHOD("material_get", "index"), &PropInstanceMerger2D::material_get);
ClassDB::bind_method(D_METHOD("material_add", "value"), &PropInstanceMerger::material_add); ClassDB::bind_method(D_METHOD("material_add", "value"), &PropInstanceMerger2D::material_add);
ClassDB::bind_method(D_METHOD("material_get_num"), &PropInstanceMerger::material_get_num); ClassDB::bind_method(D_METHOD("material_get_num"), &PropInstanceMerger2D::material_get_num);
ClassDB::bind_method(D_METHOD("materials_clear"), &PropInstanceMerger::materials_clear); ClassDB::bind_method(D_METHOD("materials_clear"), &PropInstanceMerger2D::materials_clear);
ClassDB::bind_method(D_METHOD("materials_get"), &PropInstanceMerger::materials_get); ClassDB::bind_method(D_METHOD("materials_get"), &PropInstanceMerger2D::materials_get);
ClassDB::bind_method(D_METHOD("materials_set"), &PropInstanceMerger::materials_set); ClassDB::bind_method(D_METHOD("materials_set"), &PropInstanceMerger2D::materials_set);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "materials_set", "materials_get"); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "materials_set", "materials_get");
//Meshes //Meshes
ClassDB::bind_method(D_METHOD("mesh_get", "index"), &PropInstanceMerger::mesh_get); ClassDB::bind_method(D_METHOD("mesh_get", "index"), &PropInstanceMerger2D::mesh_get);
ClassDB::bind_method(D_METHOD("mesh_instance_get", "index"), &PropInstanceMerger::mesh_instance_get); ClassDB::bind_method(D_METHOD("mesh_instance_get", "index"), &PropInstanceMerger2D::mesh_instance_get);
ClassDB::bind_method(D_METHOD("mesh_add", "mesh_instance", "mesh"), &PropInstanceMerger::mesh_add); ClassDB::bind_method(D_METHOD("mesh_add", "mesh_instance", "mesh"), &PropInstanceMerger2D::mesh_add);
ClassDB::bind_method(D_METHOD("mesh_get_num"), &PropInstanceMerger::mesh_get_num); ClassDB::bind_method(D_METHOD("mesh_get_num"), &PropInstanceMerger2D::mesh_get_num);
ClassDB::bind_method(D_METHOD("meshes_clear"), &PropInstanceMerger::meshes_clear); ClassDB::bind_method(D_METHOD("meshes_clear"), &PropInstanceMerger2D::meshes_clear);
ClassDB::bind_method(D_METHOD("meshes_get"), &PropInstanceMerger::meshes_get); ClassDB::bind_method(D_METHOD("meshes_get"), &PropInstanceMerger2D::meshes_get);
ClassDB::bind_method(D_METHOD("meshes_set"), &PropInstanceMerger::meshes_set); ClassDB::bind_method(D_METHOD("meshes_set"), &PropInstanceMerger2D::meshes_set);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "meshes", PROPERTY_HINT_NONE, "", 0), "meshes_set", "meshes_get"); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "meshes", PROPERTY_HINT_NONE, "", 0), "meshes_set", "meshes_get");
//Colliders //Colliders
ClassDB::bind_method(D_METHOD("collider_local_transform_get", "index"), &PropInstanceMerger::collider_local_transform_get); ClassDB::bind_method(D_METHOD("collider_local_transform_get", "index"), &PropInstanceMerger2D::collider_local_transform_get);
ClassDB::bind_method(D_METHOD("collider_body_get", "index"), &PropInstanceMerger::collider_body_get); ClassDB::bind_method(D_METHOD("collider_body_get", "index"), &PropInstanceMerger2D::collider_body_get);
ClassDB::bind_method(D_METHOD("collider_shape_get", "index"), &PropInstanceMerger::collider_shape_get); ClassDB::bind_method(D_METHOD("collider_shape_get", "index"), &PropInstanceMerger2D::collider_shape_get);
ClassDB::bind_method(D_METHOD("collider_shape_rid_get", "index"), &PropInstanceMerger::collider_shape_rid_get); ClassDB::bind_method(D_METHOD("collider_shape_rid_get", "index"), &PropInstanceMerger2D::collider_shape_rid_get);
ClassDB::bind_method(D_METHOD("collider_add", "local_transform", "shape", "shape_rid", "body"), &PropInstanceMerger::collider_add); ClassDB::bind_method(D_METHOD("collider_add", "local_transform", "shape", "shape_rid", "body"), &PropInstanceMerger2D::collider_add);
ClassDB::bind_method(D_METHOD("collider_get_num"), &PropInstanceMerger::collider_get_num); ClassDB::bind_method(D_METHOD("collider_get_num"), &PropInstanceMerger2D::collider_get_num);
ClassDB::bind_method(D_METHOD("colliders_clear"), &PropInstanceMerger::colliders_clear); ClassDB::bind_method(D_METHOD("colliders_clear"), &PropInstanceMerger2D::colliders_clear);
ClassDB::bind_method(D_METHOD("meshes_create", "num"), &PropInstanceMerger::meshes_create); ClassDB::bind_method(D_METHOD("meshes_create", "num"), &PropInstanceMerger2D::meshes_create);
//Colliders //Colliders
ClassDB::bind_method(D_METHOD("debug_mesh_allocate"), &PropInstanceMerger::debug_mesh_allocate); ClassDB::bind_method(D_METHOD("debug_mesh_allocate"), &PropInstanceMerger2D::debug_mesh_allocate);
ClassDB::bind_method(D_METHOD("debug_mesh_free"), &PropInstanceMerger::debug_mesh_free); ClassDB::bind_method(D_METHOD("debug_mesh_free"), &PropInstanceMerger2D::debug_mesh_free);
ClassDB::bind_method(D_METHOD("debug_mesh_has"), &PropInstanceMerger::debug_mesh_has); ClassDB::bind_method(D_METHOD("debug_mesh_has"), &PropInstanceMerger2D::debug_mesh_has);
ClassDB::bind_method(D_METHOD("debug_mesh_clear"), &PropInstanceMerger::debug_mesh_clear); ClassDB::bind_method(D_METHOD("debug_mesh_clear"), &PropInstanceMerger2D::debug_mesh_clear);
ClassDB::bind_method(D_METHOD("debug_mesh_array_clear"), &PropInstanceMerger::debug_mesh_array_clear); ClassDB::bind_method(D_METHOD("debug_mesh_array_clear"), &PropInstanceMerger2D::debug_mesh_array_clear);
ClassDB::bind_method(D_METHOD("debug_mesh_add_vertices_to", "arr"), &PropInstanceMerger::debug_mesh_add_vertices_to); ClassDB::bind_method(D_METHOD("debug_mesh_add_vertices_to", "arr"), &PropInstanceMerger2D::debug_mesh_add_vertices_to);
ClassDB::bind_method(D_METHOD("debug_mesh_send"), &PropInstanceMerger::debug_mesh_send); ClassDB::bind_method(D_METHOD("debug_mesh_send"), &PropInstanceMerger2D::debug_mesh_send);
ClassDB::bind_method(D_METHOD("draw_debug_mdr_colliders"), &PropInstanceMerger::draw_debug_mdr_colliders); ClassDB::bind_method(D_METHOD("draw_debug_mdr_colliders"), &PropInstanceMerger2D::draw_debug_mdr_colliders);
ClassDB::bind_method(D_METHOD("check_auto_lod"), &PropInstanceMerger::check_auto_lod); ClassDB::bind_method(D_METHOD("check_auto_lod"), &PropInstanceMerger2D::check_auto_lod);
ClassDB::bind_method(D_METHOD("apply_lod_level"), &PropInstanceMerger::apply_lod_level); ClassDB::bind_method(D_METHOD("apply_lod_level"), &PropInstanceMerger2D::apply_lod_level);
//--- //---
ClassDB::bind_method(D_METHOD("free_meshes"), &PropInstanceMerger::free_meshes); ClassDB::bind_method(D_METHOD("free_meshes"), &PropInstanceMerger2D::free_meshes);
ClassDB::bind_method(D_METHOD("free_colliders"), &PropInstanceMerger::free_colliders); ClassDB::bind_method(D_METHOD("free_colliders"), &PropInstanceMerger2D::free_colliders);
} }

16
prop_instance_merger_2d.h
View File

@ -43,8 +43,8 @@ SOFTWARE.
class MeshDataInstance; class MeshDataInstance;
class PropInstanceMerger : public PropInstance { class PropInstanceMerger2D : public PropInstance2D {
GDCLASS(PropInstanceMerger, PropInstance); GDCLASS(PropInstanceMerger2D, PropInstance2D);
public: public:
static const float LOD_CHECK_INTERVAL; static const float LOD_CHECK_INTERVAL;
@ -64,8 +64,8 @@ public:
float get_lod_reduction_distance_squared(); float get_lod_reduction_distance_squared();
void set_lod_reduction_distance_squared(const float dist); void set_lod_reduction_distance_squared(const float dist);
Ref<PropInstanceJob> get_job(); Ref<PropInstanceJob2D> get_job();
void set_job(const Ref<PropInstanceJob> &job); void set_job(const Ref<PropInstanceJob2D> &job);
///Materials ///Materials
Ref<Material> material_get(const int index); Ref<Material> material_get(const int index);
@ -120,13 +120,13 @@ public:
virtual void _build(); virtual void _build();
virtual void _build_finished(); virtual void _build_finished();
void _prop_preprocess(Transform tarnsform, const Ref<PropData> &prop); void _prop_preprocess(Transform tarnsform, const Ref<PropData2D> &prop);
void collision_layer_changed(); void collision_layer_changed();
void collision_mask_changed(); void collision_mask_changed();
PropInstanceMerger(); PropInstanceMerger2D();
~PropInstanceMerger(); ~PropInstanceMerger2D();
protected: protected:
void _notification(int p_what); void _notification(int p_what);
@ -158,7 +158,7 @@ private:
Transform _last_transform; Transform _last_transform;
Ref<PropInstancePropJob> _job; Ref<PropInstancePropJob2D> _job;
Vector<Ref<Material>> _materials; Vector<Ref<Material>> _materials;
Vector<MeshEntry> _meshes; Vector<MeshEntry> _meshes;

154
prop_instance_prop_job_2d.cpp
View File

@ -62,36 +62,36 @@ SOFTWARE.
#include "props/prop_data_tiled_wall_2d.h" #include "props/prop_data_tiled_wall_2d.h"
#include "tiled_wall/tiled_wall_data_2d.h" #include "tiled_wall/tiled_wall_data_2d.h"
Ref<PropMaterialCache> PropInstancePropJob::get_material_cache() { Ref<PropMaterialCache2D> PropInstancePropJob2D::get_material_cache() {
return _material_cache; return _material_cache;
} }
void PropInstancePropJob::set_material_cache(const Ref<PropMaterialCache> &cache) { void PropInstancePropJob2D::set_material_cache(const Ref<PropMaterialCache2D> &cache) {
_material_cache = cache; _material_cache = cache;
} }
Ref<PropMesherJobStep> PropInstancePropJob::get_jobs_step(int index) const { Ref<PropMesherJobStep2D> PropInstancePropJob2D::get_jobs_step(int index) const {
ERR_FAIL_INDEX_V(index, _job_steps.size(), Ref<PropMesherJobStep>()); ERR_FAIL_INDEX_V(index, _job_steps.size(), Ref<PropMesherJobStep2D>());
return _job_steps.get(index); return _job_steps.get(index);
} }
void PropInstancePropJob::set_jobs_step(int index, const Ref<PropMesherJobStep> &step) { void PropInstancePropJob2D::set_jobs_step(int index, const Ref<PropMesherJobStep2D> &step) {
ERR_FAIL_INDEX(index, _job_steps.size()); ERR_FAIL_INDEX(index, _job_steps.size());
_job_steps.set(index, step); _job_steps.set(index, step);
} }
void PropInstancePropJob::remove_jobs_step(const int index) { void PropInstancePropJob2D::remove_jobs_step(const int index) {
ERR_FAIL_INDEX(index, _job_steps.size()); ERR_FAIL_INDEX(index, _job_steps.size());
_job_steps.remove(index); _job_steps.remove(index);
} }
void PropInstancePropJob::add_jobs_step(const Ref<PropMesherJobStep> &step) { void PropInstancePropJob2D::add_jobs_step(const Ref<PropMesherJobStep2D> &step) {
_job_steps.push_back(step); _job_steps.push_back(step);
} }
int PropInstancePropJob::get_jobs_step_count() const { int PropInstancePropJob2D::get_jobs_step_count() const {
return _job_steps.size(); return _job_steps.size();
} }
void PropInstancePropJob::add_collision_shape(const Ref<Shape> &shape, const Transform &transform, const bool owns_shape) { void PropInstancePropJob2D::add_collision_shape(const Ref<Shape> &shape, const Transform &transform, const bool owns_shape) {
CollisionShapeEntry e; CollisionShapeEntry e;
e.shape = shape; e.shape = shape;
@ -100,30 +100,30 @@ void PropInstancePropJob::add_collision_shape(const Ref<Shape> &shape, const Tra
_collision_shapes.push_back(e); _collision_shapes.push_back(e);
} }
void PropInstancePropJob::clear_collision_shapes() { void PropInstancePropJob2D::clear_collision_shapes() {
_collision_shapes.clear(); _collision_shapes.clear();
} }
PropInstanceMerger *PropInstancePropJob::get_prop_instace() { PropInstanceMerger2D *PropInstancePropJob2D::get_prop_instace() {
return _prop_instace; return _prop_instace;
} }
void PropInstancePropJob::set_prop_instace(PropInstanceMerger *prop) { void PropInstancePropJob2D::set_prop_instace(PropInstanceMerger2D *prop) {
_prop_instace = prop; _prop_instace = prop;
_instance = prop; _instance = prop;
} }
void PropInstancePropJob::set_prop_instace_bind(Node *prop) { void PropInstancePropJob2D::set_prop_instace_bind(Node *prop) {
set_prop_instace(Object::cast_to<PropInstanceMerger>(prop)); set_prop_instace(Object::cast_to<PropInstanceMerger2D>(prop));
} }
Ref<PropMesher> PropInstancePropJob::get_prop_mesher() const { Ref<PropMesher2D> PropInstancePropJob2D::get_prop_mesher() const {
return _prop_mesher; return _prop_mesher;
} }
void PropInstancePropJob::set_prop_mesher(const Ref<PropMesher> &mesher) { void PropInstancePropJob2D::set_prop_mesher(const Ref<PropMesher2D> &mesher) {
_prop_mesher = mesher; _prop_mesher = mesher;
} }
#if MESH_DATA_RESOURCE_PRESENT #if MESH_DATA_RESOURCE_PRESENT
void PropInstancePropJob::add_mesh(const Ref<PropDataMeshData> &mesh_data, const Transform &base_transform) { void PropInstancePropJob2D::add_mesh(const Ref<PropDataMeshData2D> &mesh_data, const Transform &base_transform) {
PMDREntry e; PMDREntry e;
e.mesh_data = mesh_data; e.mesh_data = mesh_data;
e.base_transform = base_transform; e.base_transform = base_transform;
@ -131,12 +131,12 @@ void PropInstancePropJob::add_mesh(const Ref<PropDataMeshData> &mesh_data, const
_prop_mesh_datas.push_back(e); _prop_mesh_datas.push_back(e);
} }
void PropInstancePropJob::clear_meshes() { void PropInstancePropJob2D::clear_meshes() {
_prop_mesh_datas.clear(); _prop_mesh_datas.clear();
} }
#endif #endif
void PropInstancePropJob::add_tiled_wall(const Ref<PropDataTiledWall> &data, const Transform &base_transform) { void PropInstancePropJob2D::add_tiled_wall(const Ref<PropDataTiledWall2D> &data, const Transform &base_transform) {
PTWEntry e; PTWEntry e;
e.data = data; e.data = data;
e.base_transform = base_transform; e.base_transform = base_transform;
@ -144,25 +144,25 @@ void PropInstancePropJob::add_tiled_wall(const Ref<PropDataTiledWall> &data, con
_prop_tiled_wall_datas.push_back(e); _prop_tiled_wall_datas.push_back(e);
} }
void PropInstancePropJob::clear_tiled_walls() { void PropInstancePropJob2D::clear_tiled_walls() {
_prop_tiled_wall_datas.clear(); _prop_tiled_wall_datas.clear();
} }
void PropInstancePropJob::add_light(const Ref<PropLight> &light) { void PropInstancePropJob2D::add_light(const Ref<PropLight2D> &light) {
_prop_mesher->add_light(light); _prop_mesher->add_light(light);
} }
void PropInstancePropJob::clear_lights() { void PropInstancePropJob2D::clear_lights() {
_prop_mesher->clear_lights(); _prop_mesher->clear_lights();
} }
void PropInstancePropJob::_physics_process(float delta) { void PropInstancePropJob2D::_physics_process(float delta) {
if (_phase == 0) if (_phase == 0)
phase_physics_process(); phase_physics_process();
} }
void PropInstancePropJob::_execute_phase() { void PropInstancePropJob2D::_execute_phase() {
if (!_material_cache.is_valid()) { if (!_material_cache.is_valid()) {
ERR_PRINT("!PropInstancePropJob::_execute_phase(): !_material_cache.is_valid()"); ERR_PRINT("!PropInstancePropJob2D::_execute_phase(): !_material_cache.is_valid()");
//reset_meshes(); //reset_meshes();
set_complete(true); //So threadpool knows it's done set_complete(true); //So threadpool knows it's done
finished(); finished();
@ -186,12 +186,12 @@ void PropInstancePropJob::_execute_phase() {
} else if (_phase > 3) { } else if (_phase > 3) {
set_complete(true); //So threadpool knows it's done set_complete(true); //So threadpool knows it's done
finished(); finished();
ERR_FAIL_MSG("PropInstancePropJob: _phase is too high!"); ERR_FAIL_MSG("PropInstancePropJob2D: _phase is too high!");
} }
} }
void PropInstancePropJob::_reset() { void PropInstancePropJob2D::_reset() {
PropInstanceJob::_reset(); PropInstanceJob2D::_reset();
_build_done = false; _build_done = false;
_phase = 0; _phase = 0;
@ -216,7 +216,7 @@ void PropInstancePropJob::_reset() {
set_build_phase_type(BUILD_PHASE_TYPE_PHYSICS_PROCESS); set_build_phase_type(BUILD_PHASE_TYPE_PHYSICS_PROCESS);
} }
void PropInstancePropJob::phase_physics_process() { void PropInstancePropJob2D::phase_physics_process() {
//TODO this should only update the differences //TODO this should only update the differences
//for (int i = 0; i < _prop_instace->collider_get_num(); ++i) { //for (int i = 0; i < _prop_instace->collider_get_num(); ++i) {
// PhysicsServer::get_singleton()->free(_prop_instace->collider_body_get(i)); // PhysicsServer::get_singleton()->free(_prop_instace->collider_body_get(i));
@ -263,7 +263,7 @@ void PropInstancePropJob::phase_physics_process() {
next_phase(); next_phase();
} }
void PropInstancePropJob::phase_setup_cache() { void PropInstancePropJob2D::phase_setup_cache() {
if (should_do()) { if (should_do()) {
if (!_material_cache->get_initialized()) { if (!_material_cache->get_initialized()) {
_material_cache->mutex_lock(); _material_cache->mutex_lock();
@ -292,7 +292,7 @@ void PropInstancePropJob::phase_setup_cache() {
next_phase(); next_phase();
} }
void PropInstancePropJob::phase_prop() { void PropInstancePropJob2D::phase_prop() {
if (!_prop_mesher.is_valid()) { if (!_prop_mesher.is_valid()) {
set_complete(true); //So threadpool knows it's done set_complete(true); //So threadpool knows it's done
return; return;
@ -330,7 +330,7 @@ void PropInstancePropJob::phase_prop() {
for (int i = 0; i < _prop_tiled_wall_datas.size(); ++i) { for (int i = 0; i < _prop_tiled_wall_datas.size(); ++i) {
PTWEntry &e = _prop_tiled_wall_datas.write[i]; PTWEntry &e = _prop_tiled_wall_datas.write[i];
Ref<PropDataTiledWall> pdtw = e.data; Ref<PropDataTiledWall2D> pdtw = e.data;
//Transform t = pdtw->get_transform(); //Transform t = pdtw->get_transform();
Transform t = e.base_transform; Transform t = e.base_transform;
@ -352,7 +352,7 @@ void PropInstancePropJob::phase_prop() {
} }
if (should_do()) { if (should_do()) {
if ((_prop_mesher->get_build_flags() & PropMesher::BUILD_FLAG_USE_LIGHTING) != 0) { if ((_prop_mesher->get_build_flags() & PropMesher2D::BUILD_FLAG_USE_LIGHTING) != 0) {
_prop_mesher->bake_colors(); _prop_mesher->bake_colors();
} }
@ -365,7 +365,7 @@ void PropInstancePropJob::phase_prop() {
next_phase(); next_phase();
} }
void PropInstancePropJob::phase_steps() { void PropInstancePropJob2D::phase_steps() {
ERR_FAIL_COND(!_prop_mesher.is_valid()); ERR_FAIL_COND(!_prop_mesher.is_valid());
if (should_return()) { if (should_return()) {
@ -388,27 +388,27 @@ void PropInstancePropJob::phase_steps() {
//first count how many we need //first count how many we need
int count = 0; int count = 0;
for (int i = 0; i < _job_steps.size(); ++i) { for (int i = 0; i < _job_steps.size(); ++i) {
Ref<PropMesherJobStep> step = _job_steps[i]; Ref<PropMesherJobStep2D> step = _job_steps[i];
ERR_FAIL_COND(!step.is_valid()); ERR_FAIL_COND(!step.is_valid());
switch (step->get_job_type()) { switch (step->get_job_type()) {
case PropMesherJobStep::TYPE_NORMAL: case PropMesherJobStep2D::TYPE_NORMAL:
++count; ++count;
break; break;
case PropMesherJobStep::TYPE_NORMAL_LOD: case PropMesherJobStep2D::TYPE_NORMAL_LOD:
++count; ++count;
break; break;
case PropMesherJobStep::TYPE_DROP_UV2: case PropMesherJobStep2D::TYPE_DROP_UV2:
++count; ++count;
break; break;
case PropMesherJobStep::TYPE_MERGE_VERTS: case PropMesherJobStep2D::TYPE_MERGE_VERTS:
++count; ++count;
break; break;
case PropMesherJobStep::TYPE_BAKE_TEXTURE: case PropMesherJobStep2D::TYPE_BAKE_TEXTURE:
++count; ++count;
break; break;
case PropMesherJobStep::TYPE_SIMPLIFY_MESH: case PropMesherJobStep2D::TYPE_SIMPLIFY_MESH:
#ifdef MESH_UTILS_PRESENT #ifdef MESH_UTILS_PRESENT
count += step->get_simplification_steps(); count += step->get_simplification_steps();
#endif #endif
@ -441,30 +441,30 @@ void PropInstancePropJob::phase_steps() {
} }
for (; _current_job_step < _job_steps.size();) { for (; _current_job_step < _job_steps.size();) {
Ref<PropMesherJobStep> step = _job_steps[_current_job_step]; Ref<PropMesherJobStep2D> step = _job_steps[_current_job_step];
ERR_FAIL_COND(!step.is_valid()); ERR_FAIL_COND(!step.is_valid());
switch (step->get_job_type()) { switch (step->get_job_type()) {
case PropMesherJobStep::TYPE_NORMAL: case PropMesherJobStep2D::TYPE_NORMAL:
step_type_normal(); step_type_normal();
break; break;
case PropMesherJobStep::TYPE_NORMAL_LOD: case PropMesherJobStep2D::TYPE_NORMAL_LOD:
step_type_normal_lod(); step_type_normal_lod();
break; break;
case PropMesherJobStep::TYPE_DROP_UV2: case PropMesherJobStep2D::TYPE_DROP_UV2:
step_type_drop_uv2(); step_type_drop_uv2();
break; break;
case PropMesherJobStep::TYPE_MERGE_VERTS: case PropMesherJobStep2D::TYPE_MERGE_VERTS:
step_type_merge_verts(); step_type_merge_verts();
break; break;
case PropMesherJobStep::TYPE_BAKE_TEXTURE: case PropMesherJobStep2D::TYPE_BAKE_TEXTURE:
step_type_bake_texture(); step_type_bake_texture();
break; break;
case PropMesherJobStep::TYPE_SIMPLIFY_MESH: case PropMesherJobStep2D::TYPE_SIMPLIFY_MESH:
step_type_simplify_mesh(); step_type_simplify_mesh();
break; break;
case PropMesherJobStep::TYPE_OTHER: case PropMesherJobStep2D::TYPE_OTHER:
//do nothing //do nothing
break; break;
} }
@ -482,7 +482,7 @@ void PropInstancePropJob::phase_steps() {
finished(); finished();
} }
void PropInstancePropJob::step_type_normal() { void PropInstancePropJob2D::step_type_normal() {
//TODO add a lighting generation step //TODO add a lighting generation step
temp_mesh_arr = _prop_mesher->build_mesh(); temp_mesh_arr = _prop_mesher->build_mesh();
@ -500,13 +500,13 @@ void PropInstancePropJob::step_type_normal() {
++_current_mesh; ++_current_mesh;
} }
void PropInstancePropJob::step_type_normal_lod() { void PropInstancePropJob2D::step_type_normal_lod() {
print_error("Error: step_type_normal_lod doesn't work for TerraPropJobs!"); print_error("Error: step_type_normal_lod doesn't work for TerraPropJobs!");
++_current_mesh; ++_current_mesh;
} }
void PropInstancePropJob::step_type_drop_uv2() { void PropInstancePropJob2D::step_type_drop_uv2() {
RID mesh_rid = _prop_instace->mesh_get(_current_mesh); RID mesh_rid = _prop_instace->mesh_get(_current_mesh);
temp_mesh_arr[VisualServer::ARRAY_TEX_UV2] = Variant(); temp_mesh_arr[VisualServer::ARRAY_TEX_UV2] = Variant();
@ -522,7 +522,7 @@ void PropInstancePropJob::step_type_drop_uv2() {
++_current_mesh; ++_current_mesh;
} }
void PropInstancePropJob::step_type_merge_verts() { void PropInstancePropJob2D::step_type_merge_verts() {
Array temp_mesh_arr2 = merge_mesh_array(temp_mesh_arr); Array temp_mesh_arr2 = merge_mesh_array(temp_mesh_arr);
temp_mesh_arr = temp_mesh_arr2; temp_mesh_arr = temp_mesh_arr2;
@ -539,7 +539,7 @@ void PropInstancePropJob::step_type_merge_verts() {
++_current_mesh; ++_current_mesh;
} }
void PropInstancePropJob::step_type_bake_texture() { void PropInstancePropJob2D::step_type_bake_texture() {
Ref<ShaderMaterial> mat = _material_cache->material_lod_get(0); Ref<ShaderMaterial> mat = _material_cache->material_lod_get(0);
Ref<SpatialMaterial> spmat = _material_cache->material_lod_get(0); Ref<SpatialMaterial> spmat = _material_cache->material_lod_get(0);
Ref<Texture> tex; Ref<Texture> tex;
@ -568,10 +568,10 @@ void PropInstancePropJob::step_type_bake_texture() {
++_current_mesh; ++_current_mesh;
} }
void PropInstancePropJob::step_type_simplify_mesh() { void PropInstancePropJob2D::step_type_simplify_mesh() {
#ifdef MESH_UTILS_PRESENT #ifdef MESH_UTILS_PRESENT
Ref<PropMesherJobStep> step = _job_steps[_current_job_step]; Ref<PropMesherJobStep2D> step = _job_steps[_current_job_step];
ERR_FAIL_COND(!step.is_valid()); ERR_FAIL_COND(!step.is_valid());
Ref<FastQuadraticMeshSimplifier> fqms = step->get_fqms(); Ref<FastQuadraticMeshSimplifier> fqms = step->get_fqms();
ERR_FAIL_COND(!fqms.is_valid()); ERR_FAIL_COND(!fqms.is_valid());
@ -598,7 +598,7 @@ void PropInstancePropJob::step_type_simplify_mesh() {
#endif #endif
} }
Array PropInstancePropJob::merge_mesh_array(Array arr) const { Array PropInstancePropJob2D::merge_mesh_array(Array arr) const {
ERR_FAIL_COND_V(arr.size() != VisualServer::ARRAY_MAX, arr); ERR_FAIL_COND_V(arr.size() != VisualServer::ARRAY_MAX, arr);
PoolVector3Array verts = arr[VisualServer::ARRAY_VERTEX]; PoolVector3Array verts = arr[VisualServer::ARRAY_VERTEX];
@ -662,7 +662,7 @@ Array PropInstancePropJob::merge_mesh_array(Array arr) const {
return arr; return arr;
} }
Array PropInstancePropJob::bake_mesh_array_uv(Array arr, Ref<Texture> tex, const float mul_color) const { Array PropInstancePropJob2D::bake_mesh_array_uv(Array arr, Ref<Texture> tex, const float mul_color) const {
ERR_FAIL_COND_V(arr.size() != VisualServer::ARRAY_MAX, arr); ERR_FAIL_COND_V(arr.size() != VisualServer::ARRAY_MAX, arr);
ERR_FAIL_COND_V(!tex.is_valid(), arr); ERR_FAIL_COND_V(!tex.is_valid(), arr);
@ -703,7 +703,7 @@ Array PropInstancePropJob::bake_mesh_array_uv(Array arr, Ref<Texture> tex, const
return arr; return arr;
} }
void PropInstancePropJob::reset_meshes() { void PropInstancePropJob2D::reset_meshes() {
if (!_prop_instace) { if (!_prop_instace) {
return; return;
} }
@ -725,7 +725,7 @@ void PropInstancePropJob::reset_meshes() {
} }
} }
PropInstancePropJob::PropInstancePropJob() { PropInstancePropJob2D::PropInstancePropJob2D() {
set_build_phase_type(BUILD_PHASE_TYPE_PHYSICS_PROCESS); set_build_phase_type(BUILD_PHASE_TYPE_PHYSICS_PROCESS);
_prop_instace = NULL; _prop_instace = NULL;
@ -734,29 +734,29 @@ PropInstancePropJob::PropInstancePropJob() {
//todo allocate this in a virtual method //todo allocate this in a virtual method
_prop_mesher.instance(); _prop_mesher.instance();
_prop_mesher->set_build_flags(PropMesher::BUILD_FLAG_USE_LIGHTING | PropMesher::BUILD_FLAG_USE_AO | PropMesher::BUILD_FLAG_USE_RAO | PropMesher::BUILD_FLAG_BAKE_LIGHTS); _prop_mesher->set_build_flags(PropMesher2D::BUILD_FLAG_USE_LIGHTING | PropMesher2D::BUILD_FLAG_USE_AO | PropMesher2D::BUILD_FLAG_USE_RAO | PropMesher2D::BUILD_FLAG_BAKE_LIGHTS);
} }
PropInstancePropJob::~PropInstancePropJob() { PropInstancePropJob2D::~PropInstancePropJob2D() {
} }
void PropInstancePropJob::_bind_methods() { void PropInstancePropJob2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_material_cache"), &PropInstancePropJob::get_material_cache); ClassDB::bind_method(D_METHOD("get_material_cache"), &PropInstancePropJob2D::get_material_cache);
ClassDB::bind_method(D_METHOD("set_material_cache", "packer"), &PropInstancePropJob::set_material_cache); ClassDB::bind_method(D_METHOD("set_material_cache", "packer"), &PropInstancePropJob2D::set_material_cache);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material_cache", PROPERTY_HINT_RESOURCE_TYPE, "PropMaterialCache", 0), "set_material_cache", "get_material_cache"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material_cache", PROPERTY_HINT_RESOURCE_TYPE, "PropMaterialCache2D", 0), "set_material_cache", "get_material_cache");
ClassDB::bind_method(D_METHOD("get_jobs_step", "index"), &PropInstancePropJob::get_jobs_step); ClassDB::bind_method(D_METHOD("get_jobs_step", "index"), &PropInstancePropJob2D::get_jobs_step);
ClassDB::bind_method(D_METHOD("set_jobs_step", "index", "mesher"), &PropInstancePropJob::set_jobs_step); ClassDB::bind_method(D_METHOD("set_jobs_step", "index", "mesher"), &PropInstancePropJob2D::set_jobs_step);
ClassDB::bind_method(D_METHOD("remove_jobs_step", "index"), &PropInstancePropJob::remove_jobs_step); ClassDB::bind_method(D_METHOD("remove_jobs_step", "index"), &PropInstancePropJob2D::remove_jobs_step);
ClassDB::bind_method(D_METHOD("add_jobs_step", "mesher"), &PropInstancePropJob::add_jobs_step); ClassDB::bind_method(D_METHOD("add_jobs_step", "mesher"), &PropInstancePropJob2D::add_jobs_step);
ClassDB::bind_method(D_METHOD("get_jobs_step_count"), &PropInstancePropJob::get_jobs_step_count); ClassDB::bind_method(D_METHOD("get_jobs_step_count"), &PropInstancePropJob2D::get_jobs_step_count);
ClassDB::bind_method(D_METHOD("get_prop_mesher"), &PropInstancePropJob::get_prop_mesher); ClassDB::bind_method(D_METHOD("get_prop_mesher"), &PropInstancePropJob2D::get_prop_mesher);
ClassDB::bind_method(D_METHOD("set_prop_mesher", "mesher"), &PropInstancePropJob::set_prop_mesher); ClassDB::bind_method(D_METHOD("set_prop_mesher", "mesher"), &PropInstancePropJob2D::set_prop_mesher);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "prop_mesher", PROPERTY_HINT_RESOURCE_TYPE, "PropMesher", 0), "set_prop_mesher", "get_prop_mesher"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "prop_mesher", PROPERTY_HINT_RESOURCE_TYPE, "PropMesher2D", 0), "set_prop_mesher", "get_prop_mesher");
ClassDB::bind_method(D_METHOD("add_light", "light"), &PropInstancePropJob::add_light); ClassDB::bind_method(D_METHOD("add_light", "light"), &PropInstancePropJob2D::add_light);
ClassDB::bind_method(D_METHOD("clear_lights"), &PropInstancePropJob::clear_lights); ClassDB::bind_method(D_METHOD("clear_lights"), &PropInstancePropJob2D::clear_lights);
ClassDB::bind_method(D_METHOD("_physics_process", "delta"), &PropInstancePropJob::_physics_process); ClassDB::bind_method(D_METHOD("_physics_process", "delta"), &PropInstancePropJob2D::_physics_process);
} }

56
prop_instance_prop_job_2d.h
View File

@ -25,51 +25,51 @@ SOFTWARE.
#include "prop_instance_job_2d.h" #include "prop_instance_job_2d.h"
class PropMesher; class PropMesher2D;
class PropInstance; class PropInstance2D;
class PropInstanceMerger; class PropInstanceMerger2D;
class PropMesherJobStep; class PropMesherJobStep2D;
class PropMaterialCache; class PropMaterialCache2D;
class Shape; class Shape;
class PropLight; class PropLight2D;
class PropDataTiledWall; class PropDataTiledWall2D;
#if MESH_DATA_RESOURCE_PRESENT #if MESH_DATA_RESOURCE_PRESENT
class PropDataMeshData; class PropDataMeshData;
#endif #endif
class PropInstancePropJob : public PropInstanceJob { class PropInstancePropJob2D : public PropInstanceJob2D {
GDCLASS(PropInstancePropJob, PropInstanceJob); GDCLASS(PropInstancePropJob2D, PropInstanceJob2D);
public: public:
Ref<PropMaterialCache> get_material_cache(); Ref<PropMaterialCache2D> get_material_cache();
void set_material_cache(const Ref<PropMaterialCache> &cache); void set_material_cache(const Ref<PropMaterialCache2D> &cache);
Ref<PropMesherJobStep> get_jobs_step(const int index) const; Ref<PropMesherJobStep2D> get_jobs_step(const int index) const;
void set_jobs_step(const int index, const Ref<PropMesherJobStep> &step); void set_jobs_step(const int index, const Ref<PropMesherJobStep2D> &step);
void remove_jobs_step(const int index); void remove_jobs_step(const int index);
void add_jobs_step(const Ref<PropMesherJobStep> &step); void add_jobs_step(const Ref<PropMesherJobStep2D> &step);
int get_jobs_step_count() const; int get_jobs_step_count() const;
void add_collision_shape(const Ref<Shape> &shape, const Transform &transform, const bool owns_shape = false); void add_collision_shape(const Ref<Shape> &shape, const Transform &transform, const bool owns_shape = false);
void clear_collision_shapes(); void clear_collision_shapes();
PropInstanceMerger *get_prop_instace(); PropInstanceMerger2D *get_prop_instace();
void set_prop_instace(PropInstanceMerger *prop); void set_prop_instace(PropInstanceMerger2D *prop);
void set_prop_instace_bind(Node *prop); void set_prop_instace_bind(Node *prop);
Ref<PropMesher> get_prop_mesher() const; Ref<PropMesher2D> get_prop_mesher() const;
void set_prop_mesher(const Ref<PropMesher> &mesher); void set_prop_mesher(const Ref<PropMesher2D> &mesher);
#if MESH_DATA_RESOURCE_PRESENT #if MESH_DATA_RESOURCE_PRESENT
void add_mesh(const Ref<PropDataMeshData> &mesh_data, const Transform &base_transform); void add_mesh(const Ref<PropDataMeshData2D> &mesh_data, const Transform &base_transform);
void clear_meshes(); void clear_meshes();
#endif #endif
void add_tiled_wall(const Ref<PropDataTiledWall> &data, const Transform &base_transform); void add_tiled_wall(const Ref<PropDataTiledWall2D> &data, const Transform &base_transform);
void clear_tiled_walls(); void clear_tiled_walls();
void add_light(const Ref<PropLight> &light); void add_light(const Ref<PropLight2D> &light);
void clear_lights(); void clear_lights();
void _physics_process(float delta); void _physics_process(float delta);
@ -93,8 +93,8 @@ public:
void reset_meshes(); void reset_meshes();
PropInstancePropJob(); PropInstancePropJob2D();
~PropInstancePropJob(); ~PropInstancePropJob2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();
@ -108,7 +108,7 @@ protected:
#endif #endif
struct PTWEntry { struct PTWEntry {
Ref<PropDataTiledWall> data; Ref<PropDataTiledWall2D> data;
Transform base_transform; Transform base_transform;
}; };
@ -122,14 +122,14 @@ protected:
} }
}; };
Ref<PropMaterialCache> _material_cache; Ref<PropMaterialCache2D> _material_cache;
Vector<Ref<PropMesherJobStep>> _job_steps; Vector<Ref<PropMesherJobStep2D>> _job_steps;
int _current_job_step; int _current_job_step;
int _current_mesh; int _current_mesh;
Ref<PropMesher> _prop_mesher; Ref<PropMesher2D> _prop_mesher;
PropInstanceMerger *_prop_instace; PropInstanceMerger2D *_prop_instace;
#if MESH_DATA_RESOURCE_PRESENT #if MESH_DATA_RESOURCE_PRESENT
Vector<PMDREntry> _prop_mesh_datas; Vector<PMDREntry> _prop_mesh_datas;

328
prop_mesher_2d.cpp
View File

@ -28,9 +28,9 @@ SOFTWARE.
#include "material_cache/prop_material_cache_2d.h" #include "material_cache/prop_material_cache_2d.h"
#include "tiled_wall/tiled_wall_data_2d.h" #include "tiled_wall/tiled_wall_data_2d.h"
const String PropMesher::BINDING_STRING_BUILD_FLAGS = "Use Lighting,Use AO,Use RAO,Bake Lights"; const String PropMesher2D::BINDING_STRING_BUILD_FLAGS = "Use Lighting,Use AO,Use RAO,Bake Lights";
bool PropMesher::Vertex::operator==(const Vertex &p_vertex) const { bool PropMesher2D::Vertex::operator==(const Vertex &p_vertex) const {
if (vertex != p_vertex.vertex) if (vertex != p_vertex.vertex)
return false; return false;
@ -65,7 +65,7 @@ bool PropMesher::Vertex::operator==(const Vertex &p_vertex) const {
return true; return true;
} }
uint32_t PropMesher::VertexHasher::hash(const Vertex &p_vtx) { uint32_t PropMesher2D::VertexHasher::hash(const Vertex &p_vtx) {
uint32_t h = hash_djb2_buffer((const uint8_t *)&p_vtx.vertex, sizeof(real_t) * 3); uint32_t h = hash_djb2_buffer((const uint8_t *)&p_vtx.vertex, sizeof(real_t) * 3);
h = hash_djb2_buffer((const uint8_t *)&p_vtx.normal, sizeof(real_t) * 3, h); h = hash_djb2_buffer((const uint8_t *)&p_vtx.normal, sizeof(real_t) * 3, h);
h = hash_djb2_buffer((const uint8_t *)&p_vtx.binormal, sizeof(real_t) * 3, h); h = hash_djb2_buffer((const uint8_t *)&p_vtx.binormal, sizeof(real_t) * 3, h);
@ -78,90 +78,90 @@ uint32_t PropMesher::VertexHasher::hash(const Vertex &p_vtx) {
return h; return h;
} }
int PropMesher::get_channel_index_type() const { int PropMesher2D::get_channel_index_type() const {
return _channel_index_type; return _channel_index_type;
} }
void PropMesher::set_channel_index_type(const int value) { void PropMesher2D::set_channel_index_type(const int value) {
_channel_index_type = value; _channel_index_type = value;
} }
int PropMesher::get_channel_index_isolevel() const { int PropMesher2D::get_channel_index_isolevel() const {
return _channel_index_isolevel; return _channel_index_isolevel;
} }
void PropMesher::set_channel_index_isolevel(const int value) { void PropMesher2D::set_channel_index_isolevel(const int value) {
_channel_index_isolevel = value; _channel_index_isolevel = value;
} }
int PropMesher::get_mesher_index() const { int PropMesher2D::get_mesher_index() const {
return _mesher_index; return _mesher_index;
} }
void PropMesher::set_mesher_index(const int value) { void PropMesher2D::set_mesher_index(const int value) {
_mesher_index = value; _mesher_index = value;
} }
int PropMesher::get_format() const { int PropMesher2D::get_format() const {
return _format; return _format;
} }
void PropMesher::set_format(const int value) { void PropMesher2D::set_format(const int value) {
_format = value; _format = value;
} }
int PropMesher::get_texture_scale() const { int PropMesher2D::get_texture_scale() const {
return _texture_scale; return _texture_scale;
} }
void PropMesher::set_texture_scale(const int value) { void PropMesher2D::set_texture_scale(const int value) {
_texture_scale = value; _texture_scale = value;
} }
Ref<Material> PropMesher::get_material() { Ref<Material> PropMesher2D::get_material() {
return _material; return _material;
} }
void PropMesher::set_material(const Ref<Material> &material) { void PropMesher2D::set_material(const Ref<Material> &material) {
_material = material; _material = material;
} }
float PropMesher::get_ao_strength() const { float PropMesher2D::get_ao_strength() const {
return _ao_strength; return _ao_strength;
} }
void PropMesher::set_ao_strength(float value) { void PropMesher2D::set_ao_strength(float value) {
_ao_strength = value; _ao_strength = value;
} }
float PropMesher::get_base_light_value() const { float PropMesher2D::get_base_light_value() const {
return _base_light_value; return _base_light_value;
} }
void PropMesher::set_base_light_value(float value) { void PropMesher2D::set_base_light_value(float value) {
_base_light_value = value; _base_light_value = value;
} }
float PropMesher::get_voxel_scale() const { float PropMesher2D::get_voxel_scale() const {
return _voxel_scale; return _voxel_scale;
} }
void PropMesher::set_voxel_scale(const float voxel_scale) { void PropMesher2D::set_voxel_scale(const float voxel_scale) {
_voxel_scale = voxel_scale; _voxel_scale = voxel_scale;
} }
Rect2 PropMesher::get_uv_margin() const { Rect2 PropMesher2D::get_uv_margin() const {
return _uv_margin; return _uv_margin;
} }
void PropMesher::set_uv_margin(const Rect2 margin) { void PropMesher2D::set_uv_margin(const Rect2 margin) {
_uv_margin = margin; _uv_margin = margin;
} }
_FORCE_INLINE_ int PropMesher::get_build_flags() const { _FORCE_INLINE_ int PropMesher2D::get_build_flags() const {
return _build_flags; return _build_flags;
} }
_FORCE_INLINE_ void PropMesher::set_build_flags(const int flags) { _FORCE_INLINE_ void PropMesher2D::set_build_flags(const int flags) {
_build_flags = flags; _build_flags = flags;
if ((_build_flags & PropMesher::BUILD_FLAG_USE_LIGHTING) != 0) { if ((_build_flags & PropMesher2D::BUILD_FLAG_USE_LIGHTING) != 0) {
_format |= VisualServer::ARRAY_FORMAT_COLOR; _format |= VisualServer::ARRAY_FORMAT_COLOR;
} else { } else {
_format ^= VisualServer::ARRAY_FORMAT_COLOR; _format ^= VisualServer::ARRAY_FORMAT_COLOR;
} }
} }
Array PropMesher::build_mesh() { Array PropMesher2D::build_mesh() {
Array a; Array a;
a.resize(VisualServer::ARRAY_MAX); a.resize(VisualServer::ARRAY_MAX);
@ -305,7 +305,7 @@ Array PropMesher::build_mesh() {
return a; return a;
} }
void PropMesher::build_mesh_into(RID mesh) { void PropMesher2D::build_mesh_into(RID mesh) {
ERR_FAIL_COND(mesh == RID()); ERR_FAIL_COND(mesh == RID());
VS::get_singleton()->mesh_clear(mesh); VS::get_singleton()->mesh_clear(mesh);
@ -323,7 +323,7 @@ void PropMesher::build_mesh_into(RID mesh) {
VS::get_singleton()->mesh_surface_set_material(mesh, 0, _material->get_rid()); VS::get_singleton()->mesh_surface_set_material(mesh, 0, _material->get_rid());
} }
void PropMesher::generate_normals(bool p_flip) { void PropMesher2D::generate_normals(bool p_flip) {
_format = _format | VisualServer::ARRAY_FORMAT_NORMAL; _format = _format | VisualServer::ARRAY_FORMAT_NORMAL;
for (int i = 0; i < _indices.size(); i += 3) { for (int i = 0; i < _indices.size(); i += 3) {
@ -355,7 +355,7 @@ void PropMesher::generate_normals(bool p_flip) {
} }
} }
void PropMesher::remove_doubles() { void PropMesher2D::remove_doubles() {
if (_vertices.size() == 0) if (_vertices.size() == 0)
return; return;
@ -401,7 +401,7 @@ void PropMesher::remove_doubles() {
} }
//lot faster that normal remove_doubles, but false positives can happen curtesy of hash collisions //lot faster that normal remove_doubles, but false positives can happen curtesy of hash collisions
void PropMesher::remove_doubles_hashed() { void PropMesher2D::remove_doubles_hashed() {
if (_vertices.size() == 0) if (_vertices.size() == 0)
return; return;
@ -453,7 +453,7 @@ void PropMesher::remove_doubles_hashed() {
//print_error("after " + String::num(_vertices.size()) + " " + String::num(duration.count())); //print_error("after " + String::num(_vertices.size()) + " " + String::num(duration.count()));
} }
void PropMesher::reset() { void PropMesher2D::reset() {
_vertices.resize(0); _vertices.resize(0);
_indices.resize(0); _indices.resize(0);
@ -466,7 +466,7 @@ void PropMesher::reset() {
_last_tangent = Plane(); _last_tangent = Plane();
} }
void PropMesher::add_tiled_wall_simple(const int width, const int height, const Transform &transform, const Ref<TiledWallData> &tiled_wall_data, Ref<PropMaterialCache> cache) { void PropMesher2D::add_tiled_wall_simple(const int width, const int height, const Transform &transform, const Ref<TiledWallData2D> &tiled_wall_data, Ref<PropMaterialCache2D> cache) {
ERR_FAIL_COND(!tiled_wall_data.is_valid()); ERR_FAIL_COND(!tiled_wall_data.is_valid());
ERR_FAIL_COND(!cache.is_valid()); ERR_FAIL_COND(!cache.is_valid());
ERR_FAIL_COND(width < 0); ERR_FAIL_COND(width < 0);
@ -503,11 +503,11 @@ void PropMesher::add_tiled_wall_simple(const int width, const int height, const
normal_rects.push_back(Rect2(0, 0, 1, 1)); normal_rects.push_back(Rect2(0, 0, 1, 1));
} }
TiledWallData::TiledWallTilingType tiling_type = tiled_wall_data->get_tiling_type(); TiledWallData2D::TiledWallTilingType tiling_type = tiled_wall_data->get_tiling_type();
//todo implement flavour! //todo implement flavour!
if (tiling_type == TiledWallData::TILED_WALL_TILING_TYPE_NONE) { if (tiling_type == TiledWallData2D::TILED_WALL_TILING_TYPE_NONE) {
Rect2 r = normal_rects[0]; Rect2 r = normal_rects[0];
if (flavour_rects.size() == 0) { if (flavour_rects.size() == 0) {
@ -529,7 +529,7 @@ void PropMesher::add_tiled_wall_simple(const int width, const int height, const
} }
} }
} }
} else if (tiling_type == TiledWallData::TILED_WALL_TILING_TYPE_HORIZONTAL) { } else if (tiling_type == TiledWallData2D::TILED_WALL_TILING_TYPE_HORIZONTAL) {
Rect2 r; Rect2 r;
if (flavour_rects.size() == 0) { if (flavour_rects.size() == 0) {
@ -555,7 +555,7 @@ void PropMesher::add_tiled_wall_simple(const int width, const int height, const
} }
} }
} }
} else if (tiling_type == TiledWallData::TILED_WALL_TILING_TYPE_VERTICAL) { } else if (tiling_type == TiledWallData2D::TILED_WALL_TILING_TYPE_VERTICAL) {
Rect2 r; Rect2 r;
if (flavour_rects.size() == 0) { if (flavour_rects.size() == 0) {
@ -581,7 +581,7 @@ void PropMesher::add_tiled_wall_simple(const int width, const int height, const
} }
} }
} }
} else if (tiling_type == TiledWallData::TILED_WALL_TILING_TYPE_BOTH) { } else if (tiling_type == TiledWallData2D::TILED_WALL_TILING_TYPE_BOTH) {
Rect2 r; Rect2 r;
if (flavour_rects.size() == 0) { if (flavour_rects.size() == 0) {
@ -610,7 +610,7 @@ void PropMesher::add_tiled_wall_simple(const int width, const int height, const
} }
} }
void PropMesher::add_tiled_wall_mesh_rect_simple(const int x, const int y, const Transform &transform, const Rect2 &texture_rect) { void PropMesher2D::add_tiled_wall_mesh_rect_simple(const int x, const int y, const Transform &transform, const Rect2 &texture_rect) {
int vc = get_vertex_count(); int vc = get_vertex_count();
//x + 1, y //x + 1, y
@ -641,7 +641,7 @@ void PropMesher::add_tiled_wall_mesh_rect_simple(const int x, const int y, const
add_indices(vc + 0); add_indices(vc + 0);
} }
_FORCE_INLINE_ Vector2 PropMesher::transform_uv(const Vector2 &uv, const Rect2 &rect) const { _FORCE_INLINE_ Vector2 PropMesher2D::transform_uv(const Vector2 &uv, const Rect2 &rect) const {
Vector2 ruv = uv; Vector2 ruv = uv;
ruv.x *= rect.size.x; ruv.x *= rect.size.x;
@ -653,13 +653,13 @@ _FORCE_INLINE_ Vector2 PropMesher::transform_uv(const Vector2 &uv, const Rect2 &
} }
#ifdef MESH_DATA_RESOURCE_PRESENT #ifdef MESH_DATA_RESOURCE_PRESENT
void PropMesher::add_mesh_data_resource(Ref<MeshDataResource> mesh, const Vector3 position, const Vector3 rotation, const Vector3 scale, const Rect2 uv_rect) { void PropMesher2D::add_mesh_data_resource(Ref<MeshDataResource> mesh, const Vector3 position, const Vector3 rotation, const Vector3 scale, const Rect2 uv_rect) {
Transform transform = Transform(Basis(rotation).scaled(scale), position); Transform transform = Transform(Basis(rotation).scaled(scale), position);
add_mesh_data_resource_transform(mesh, transform, uv_rect); add_mesh_data_resource_transform(mesh, transform, uv_rect);
} }
void PropMesher::add_mesh_data_resource_transform(Ref<MeshDataResource> mesh, const Transform transform, const Rect2 uv_rect) { void PropMesher2D::add_mesh_data_resource_transform(Ref<MeshDataResource> mesh, const Transform transform, const Rect2 uv_rect) {
if (mesh->get_array().size() == 0) if (mesh->get_array().size() == 0)
return; return;
@ -703,7 +703,7 @@ void PropMesher::add_mesh_data_resource_transform(Ref<MeshDataResource> mesh, co
} }
} }
void PropMesher::add_mesh_data_resource_transform_colored(Ref<MeshDataResource> mesh, const Transform transform, const PoolColorArray &colors, const Rect2 uv_rect) { void PropMesher2D::add_mesh_data_resource_transform_colored(Ref<MeshDataResource> mesh, const Transform transform, const PoolColorArray &colors, const Rect2 uv_rect) {
if (mesh->get_array().size() == 0) if (mesh->get_array().size() == 0)
return; return;
@ -748,7 +748,7 @@ void PropMesher::add_mesh_data_resource_transform_colored(Ref<MeshDataResource>
#endif #endif
//Data Management functions //Data Management functions
void PropMesher::generate_ao() { void PropMesher2D::generate_ao() {
/* /*
ERR_FAIL_COND(!_chunk.is_valid()); ERR_FAIL_COND(!_chunk.is_valid());
@ -787,7 +787,7 @@ void PropMesher::generate_ao() {
}*/ }*/
} }
float PropMesher::get_random_ao(const Vector3 &position) { float PropMesher2D::get_random_ao(const Vector3 &position) {
float val = _noise->get_noise_3d(position.x, position.y, position.z); float val = _noise->get_noise_3d(position.x, position.y, position.z);
val *= _rao_scale_factor; val *= _rao_scale_factor;
@ -801,12 +801,12 @@ float PropMesher::get_random_ao(const Vector3 &position) {
return val; return val;
} }
Color PropMesher::get_light_color_at(const Vector3 &position, const Vector3 &normal) { Color PropMesher2D::get_light_color_at(const Vector3 &position, const Vector3 &normal) {
Vector3 v_lightDiffuse; Vector3 v_lightDiffuse;
//calculate the lights value //calculate the lights value
for (int i = 0; i < _lights.size(); ++i) { for (int i = 0; i < _lights.size(); ++i) {
Ref<PropLight> light = _lights.get(i); Ref<PropLight2D> light = _lights.get(i);
Vector3 lightDir = light->get_position() - position; Vector3 lightDir = light->get_position() - position;
@ -843,10 +843,10 @@ Color PropMesher::get_light_color_at(const Vector3 &position, const Vector3 &nor
return Color(v_lightDiffuse.x, v_lightDiffuse.y, v_lightDiffuse.z); return Color(v_lightDiffuse.x, v_lightDiffuse.y, v_lightDiffuse.z);
} }
void PropMesher::add_mesher(const Ref<PropMesher> &mesher) { void PropMesher2D::add_mesher(const Ref<PropMesher2D> &mesher) {
call("_add_mesher", mesher); call("_add_mesher", mesher);
} }
void PropMesher::_add_mesher(const Ref<PropMesher> &mesher) { void PropMesher2D::_add_mesher(const Ref<PropMesher2D> &mesher) {
int orig_size = _vertices.size(); int orig_size = _vertices.size();
_vertices.append_array(mesher->_vertices); _vertices.append_array(mesher->_vertices);
@ -864,14 +864,14 @@ void PropMesher::_add_mesher(const Ref<PropMesher> &mesher) {
} }
} }
void PropMesher::add_light(const Ref<PropLight> &light) { void PropMesher2D::add_light(const Ref<PropLight2D> &light) {
_lights.push_back(light); _lights.push_back(light);
} }
void PropMesher::clear_lights() { void PropMesher2D::clear_lights() {
_lights.clear(); _lights.clear();
} }
PoolVector<Vector3> PropMesher::build_collider() const { PoolVector<Vector3> PropMesher2D::build_collider() const {
PoolVector<Vector3> face_points; PoolVector<Vector3> face_points;
if (_vertices.size() == 0) if (_vertices.size() == 0)
@ -901,13 +901,13 @@ PoolVector<Vector3> PropMesher::build_collider() const {
return face_points; return face_points;
} }
void PropMesher::bake_colors() { void PropMesher2D::bake_colors() {
if ((get_build_flags() & PropMesher::BUILD_FLAG_USE_LIGHTING) == 0) { if ((get_build_flags() & PropMesher2D::BUILD_FLAG_USE_LIGHTING) == 0) {
return; return;
} }
bool rao = (get_build_flags() & PropMesher::BUILD_FLAG_USE_RAO) != 0; bool rao = (get_build_flags() & PropMesher2D::BUILD_FLAG_USE_RAO) != 0;
bool lights = (get_build_flags() & PropMesher::BUILD_FLAG_BAKE_LIGHTS) != 0; bool lights = (get_build_flags() & PropMesher2D::BUILD_FLAG_BAKE_LIGHTS) != 0;
if (rao && lights) { if (rao && lights) {
bake_colors_lights_rao(); bake_colors_lights_rao();
@ -925,7 +925,7 @@ void PropMesher::bake_colors() {
} }
} }
void PropMesher::bake_colors_rao() { void PropMesher2D::bake_colors_rao() {
for (int i = 0; i < _vertices.size(); ++i) { for (int i = 0; i < _vertices.size(); ++i) {
Vertex vertex = _vertices[i]; Vertex vertex = _vertices[i];
Vector3 vert = vertex.vertex; Vector3 vert = vertex.vertex;
@ -949,7 +949,7 @@ void PropMesher::bake_colors_rao() {
_vertices.set(i, vertex); _vertices.set(i, vertex);
} }
} }
void PropMesher::bake_colors_lights_rao() { void PropMesher2D::bake_colors_lights_rao() {
for (int i = 0; i < _vertices.size(); ++i) { for (int i = 0; i < _vertices.size(); ++i) {
Vertex vertex = _vertices[i]; Vertex vertex = _vertices[i];
Vector3 vert = vertex.vertex; Vector3 vert = vertex.vertex;
@ -977,7 +977,7 @@ void PropMesher::bake_colors_lights_rao() {
_vertices.set(i, vertex); _vertices.set(i, vertex);
} }
} }
void PropMesher::bake_colors_lights() { void PropMesher2D::bake_colors_lights() {
for (int i = 0; i < _vertices.size(); ++i) { for (int i = 0; i < _vertices.size(); ++i) {
Vertex vertex = _vertices[i]; Vertex vertex = _vertices[i];
Vector3 vert = vertex.vertex; Vector3 vert = vertex.vertex;
@ -1001,7 +1001,7 @@ void PropMesher::bake_colors_lights() {
} }
#ifdef TERRAMAN_PRESENT #ifdef TERRAMAN_PRESENT
void PropMesher::bake_lights(MeshInstance *node, Vector<Ref<TerraLight>> &lights) { void PropMesher2D::bake_lights(MeshInstance *node, Vector<Ref<TerraLight>> &lights) {
ERR_FAIL_COND(node == NULL); ERR_FAIL_COND(node == NULL);
Color darkColor(0, 0, 0, 1); Color darkColor(0, 0, 0, 1);
@ -1089,7 +1089,7 @@ void PropMesher::bake_lights(MeshInstance *node, Vector<Ref<TerraLight>> &lights
} }
#endif #endif
PoolVector<Vector3> PropMesher::get_vertices() const { PoolVector<Vector3> PropMesher2D::get_vertices() const {
PoolVector<Vector3> arr; PoolVector<Vector3> arr;
arr.resize(_vertices.size()); arr.resize(_vertices.size());
@ -1100,7 +1100,7 @@ PoolVector<Vector3> PropMesher::get_vertices() const {
return arr; return arr;
} }
void PropMesher::set_vertices(const PoolVector<Vector3> &values) { void PropMesher2D::set_vertices(const PoolVector<Vector3> &values) {
ERR_FAIL_COND(values.size() != _vertices.size()); ERR_FAIL_COND(values.size() != _vertices.size());
for (int i = 0; i < _vertices.size(); ++i) { for (int i = 0; i < _vertices.size(); ++i) {
@ -1112,11 +1112,11 @@ void PropMesher::set_vertices(const PoolVector<Vector3> &values) {
} }
} }
int PropMesher::get_vertex_count() const { int PropMesher2D::get_vertex_count() const {
return _vertices.size(); return _vertices.size();
} }
void PropMesher::add_vertex(const Vector3 &vertex) { void PropMesher2D::add_vertex(const Vector3 &vertex) {
Vertex vtx; Vertex vtx;
vtx.vertex = vertex; vtx.vertex = vertex;
vtx.color = _last_color; vtx.color = _last_color;
@ -1132,15 +1132,15 @@ void PropMesher::add_vertex(const Vector3 &vertex) {
_vertices.push_back(vtx); _vertices.push_back(vtx);
} }
Vector3 PropMesher::get_vertex(const int idx) const { Vector3 PropMesher2D::get_vertex(const int idx) const {
return _vertices.get(idx).vertex; return _vertices.get(idx).vertex;
} }
void PropMesher::remove_vertex(const int idx) { void PropMesher2D::remove_vertex(const int idx) {
_vertices.remove(idx); _vertices.remove(idx);
} }
PoolVector<Vector3> PropMesher::get_normals() const { PoolVector<Vector3> PropMesher2D::get_normals() const {
PoolVector<Vector3> arr; PoolVector<Vector3> arr;
arr.resize(_vertices.size()); arr.resize(_vertices.size());
@ -1151,7 +1151,7 @@ PoolVector<Vector3> PropMesher::get_normals() const {
return arr; return arr;
} }
void PropMesher::set_normals(const PoolVector<Vector3> &values) { void PropMesher2D::set_normals(const PoolVector<Vector3> &values) {
ERR_FAIL_COND(values.size() != _vertices.size()); ERR_FAIL_COND(values.size() != _vertices.size());
for (int i = 0; i < _vertices.size(); ++i) { for (int i = 0; i < _vertices.size(); ++i) {
@ -1163,15 +1163,15 @@ void PropMesher::set_normals(const PoolVector<Vector3> &values) {
} }
} }
void PropMesher::add_normal(const Vector3 &normal) { void PropMesher2D::add_normal(const Vector3 &normal) {
_last_normal = normal; _last_normal = normal;
} }
Vector3 PropMesher::get_normal(int idx) const { Vector3 PropMesher2D::get_normal(int idx) const {
return _vertices.get(idx).normal; return _vertices.get(idx).normal;
} }
PoolVector<Color> PropMesher::get_colors() const { PoolVector<Color> PropMesher2D::get_colors() const {
PoolVector<Color> arr; PoolVector<Color> arr;
arr.resize(_vertices.size()); arr.resize(_vertices.size());
@ -1182,7 +1182,7 @@ PoolVector<Color> PropMesher::get_colors() const {
return arr; return arr;
} }
void PropMesher::set_colors(const PoolVector<Color> &values) { void PropMesher2D::set_colors(const PoolVector<Color> &values) {
ERR_FAIL_COND(values.size() != _vertices.size()); ERR_FAIL_COND(values.size() != _vertices.size());
for (int i = 0; i < _vertices.size(); ++i) { for (int i = 0; i < _vertices.size(); ++i) {
@ -1194,15 +1194,15 @@ void PropMesher::set_colors(const PoolVector<Color> &values) {
} }
} }
void PropMesher::add_color(const Color &color) { void PropMesher2D::add_color(const Color &color) {
_last_color = color; _last_color = color;
} }
Color PropMesher::get_color(const int idx) const { Color PropMesher2D::get_color(const int idx) const {
return _vertices.get(idx).color; return _vertices.get(idx).color;
} }
PoolVector<Vector2> PropMesher::get_uvs() const { PoolVector<Vector2> PropMesher2D::get_uvs() const {
PoolVector<Vector2> arr; PoolVector<Vector2> arr;
arr.resize(_vertices.size()); arr.resize(_vertices.size());
@ -1213,7 +1213,7 @@ PoolVector<Vector2> PropMesher::get_uvs() const {
return arr; return arr;
} }
void PropMesher::set_uvs(const PoolVector<Vector2> &values) { void PropMesher2D::set_uvs(const PoolVector<Vector2> &values) {
ERR_FAIL_COND(values.size() != _vertices.size()); ERR_FAIL_COND(values.size() != _vertices.size());
for (int i = 0; i < _vertices.size(); ++i) { for (int i = 0; i < _vertices.size(); ++i) {
@ -1225,15 +1225,15 @@ void PropMesher::set_uvs(const PoolVector<Vector2> &values) {
} }
} }
void PropMesher::add_uv(const Vector2 &uv) { void PropMesher2D::add_uv(const Vector2 &uv) {
_last_uv = uv; _last_uv = uv;
} }
Vector2 PropMesher::get_uv(const int idx) const { Vector2 PropMesher2D::get_uv(const int idx) const {
return _vertices.get(idx).uv; return _vertices.get(idx).uv;
} }
PoolVector<Vector2> PropMesher::get_uv2s() const { PoolVector<Vector2> PropMesher2D::get_uv2s() const {
PoolVector<Vector2> arr; PoolVector<Vector2> arr;
arr.resize(_vertices.size()); arr.resize(_vertices.size());
@ -1244,7 +1244,7 @@ PoolVector<Vector2> PropMesher::get_uv2s() const {
return arr; return arr;
} }
void PropMesher::set_uv2s(const PoolVector<Vector2> &values) { void PropMesher2D::set_uv2s(const PoolVector<Vector2> &values) {
ERR_FAIL_COND(values.size() != _vertices.size()); ERR_FAIL_COND(values.size() != _vertices.size());
for (int i = 0; i < _vertices.size(); ++i) { for (int i = 0; i < _vertices.size(); ++i) {
@ -1256,39 +1256,39 @@ void PropMesher::set_uv2s(const PoolVector<Vector2> &values) {
} }
} }
void PropMesher::add_uv2(const Vector2 &uv) { void PropMesher2D::add_uv2(const Vector2 &uv) {
_last_uv2 = uv; _last_uv2 = uv;
} }
Vector2 PropMesher::get_uv2(const int idx) const { Vector2 PropMesher2D::get_uv2(const int idx) const {
return _vertices.get(idx).uv2; return _vertices.get(idx).uv2;
} }
PoolVector<int> PropMesher::get_indices() const { PoolVector<int> PropMesher2D::get_indices() const {
return _indices; return _indices;
} }
void PropMesher::set_indices(const PoolVector<int> &values) { void PropMesher2D::set_indices(const PoolVector<int> &values) {
_indices = values; _indices = values;
} }
int PropMesher::get_indices_count() const { int PropMesher2D::get_indices_count() const {
return _indices.size(); return _indices.size();
} }
void PropMesher::add_indices(const int index) { void PropMesher2D::add_indices(const int index) {
_indices.push_back(index); _indices.push_back(index);
} }
int PropMesher::get_index(const int idx) const { int PropMesher2D::get_index(const int idx) const {
return _indices.get(idx); return _indices.get(idx);
} }
void PropMesher::remove_index(const int idx) { void PropMesher2D::remove_index(const int idx) {
_indices.remove(idx); _indices.remove(idx);
} }
PropMesher::PropMesher() { PropMesher2D::PropMesher2D() {
_mesher_index = 0; _mesher_index = 0;
_voxel_scale = 1; _voxel_scale = 1;
_ao_strength = 0.25; _ao_strength = 0.25;
@ -1313,120 +1313,120 @@ PropMesher::PropMesher() {
_rao_seed = 2134; _rao_seed = 2134;
} }
PropMesher::~PropMesher() { PropMesher2D::~PropMesher2D() {
} }
void PropMesher::_bind_methods() { void PropMesher2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_channel_index_type"), &PropMesher::get_channel_index_type); ClassDB::bind_method(D_METHOD("get_channel_index_type"), &PropMesher2D::get_channel_index_type);
ClassDB::bind_method(D_METHOD("set_channel_index_type", "value"), &PropMesher::set_channel_index_type); ClassDB::bind_method(D_METHOD("set_channel_index_type", "value"), &PropMesher2D::set_channel_index_type);
ADD_PROPERTY(PropertyInfo(Variant::INT, "channel_index_type"), "set_channel_index_type", "get_channel_index_type"); ADD_PROPERTY(PropertyInfo(Variant::INT, "channel_index_type"), "set_channel_index_type", "get_channel_index_type");
ClassDB::bind_method(D_METHOD("get_channel_index_isolevel"), &PropMesher::get_channel_index_isolevel); ClassDB::bind_method(D_METHOD("get_channel_index_isolevel"), &PropMesher2D::get_channel_index_isolevel);
ClassDB::bind_method(D_METHOD("set_channel_index_isolevel", "value"), &PropMesher::set_channel_index_isolevel); ClassDB::bind_method(D_METHOD("set_channel_index_isolevel", "value"), &PropMesher2D::set_channel_index_isolevel);
ADD_PROPERTY(PropertyInfo(Variant::INT, "channel_index_isolevel"), "set_channel_index_isolevel", "get_channel_index_isolevel"); ADD_PROPERTY(PropertyInfo(Variant::INT, "channel_index_isolevel"), "set_channel_index_isolevel", "get_channel_index_isolevel");
ClassDB::bind_method(D_METHOD("get_mesher_index"), &PropMesher::get_mesher_index); ClassDB::bind_method(D_METHOD("get_mesher_index"), &PropMesher2D::get_mesher_index);
ClassDB::bind_method(D_METHOD("set_mesher_index", "value"), &PropMesher::set_mesher_index); ClassDB::bind_method(D_METHOD("set_mesher_index", "value"), &PropMesher2D::set_mesher_index);
ADD_PROPERTY(PropertyInfo(Variant::INT, "mesher_index"), "set_mesher_index", "get_mesher_index"); ADD_PROPERTY(PropertyInfo(Variant::INT, "mesher_index"), "set_mesher_index", "get_mesher_index");
ClassDB::bind_method(D_METHOD("get_format"), &PropMesher::get_format); ClassDB::bind_method(D_METHOD("get_format"), &PropMesher2D::get_format);
ClassDB::bind_method(D_METHOD("set_format", "value"), &PropMesher::set_format); ClassDB::bind_method(D_METHOD("set_format", "value"), &PropMesher2D::set_format);
ADD_PROPERTY(PropertyInfo(Variant::INT, "format"), "set_format", "get_format"); ADD_PROPERTY(PropertyInfo(Variant::INT, "format"), "set_format", "get_format");
ClassDB::bind_method(D_METHOD("get_texture_scale"), &PropMesher::get_texture_scale); ClassDB::bind_method(D_METHOD("get_texture_scale"), &PropMesher2D::get_texture_scale);
ClassDB::bind_method(D_METHOD("set_texture_scale", "value"), &PropMesher::set_texture_scale); ClassDB::bind_method(D_METHOD("set_texture_scale", "value"), &PropMesher2D::set_texture_scale);
ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_scale"), "set_texture_scale", "get_texture_scale"); ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_scale"), "set_texture_scale", "get_texture_scale");
ClassDB::bind_method(D_METHOD("get_material"), &PropMesher::get_material); ClassDB::bind_method(D_METHOD("get_material"), &PropMesher2D::get_material);
ClassDB::bind_method(D_METHOD("set_material", "value"), &PropMesher::set_material); ClassDB::bind_method(D_METHOD("set_material", "value"), &PropMesher2D::set_material);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_material", "get_material"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_material", "get_material");
ClassDB::bind_method(D_METHOD("get_voxel_scale"), &PropMesher::get_voxel_scale); ClassDB::bind_method(D_METHOD("get_voxel_scale"), &PropMesher2D::get_voxel_scale);
ClassDB::bind_method(D_METHOD("set_voxel_scale", "value"), &PropMesher::set_voxel_scale); ClassDB::bind_method(D_METHOD("set_voxel_scale", "value"), &PropMesher2D::set_voxel_scale);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "voxel_scale"), "set_voxel_scale", "get_voxel_scale"); ADD_PROPERTY(PropertyInfo(Variant::REAL, "voxel_scale"), "set_voxel_scale", "get_voxel_scale");
ClassDB::bind_method(D_METHOD("get_ao_strength"), &PropMesher::get_ao_strength); ClassDB::bind_method(D_METHOD("get_ao_strength"), &PropMesher2D::get_ao_strength);
ClassDB::bind_method(D_METHOD("set_ao_strength", "value"), &PropMesher::set_ao_strength); ClassDB::bind_method(D_METHOD("set_ao_strength", "value"), &PropMesher2D::set_ao_strength);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "ao_strength"), "set_ao_strength", "get_ao_strength"); ADD_PROPERTY(PropertyInfo(Variant::REAL, "ao_strength"), "set_ao_strength", "get_ao_strength");
ClassDB::bind_method(D_METHOD("get_base_light_value"), &PropMesher::get_base_light_value); ClassDB::bind_method(D_METHOD("get_base_light_value"), &PropMesher2D::get_base_light_value);
ClassDB::bind_method(D_METHOD("set_base_light_value", "value"), &PropMesher::set_base_light_value); ClassDB::bind_method(D_METHOD("set_base_light_value", "value"), &PropMesher2D::set_base_light_value);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "base_light_value"), "set_base_light_value", "get_base_light_value"); ADD_PROPERTY(PropertyInfo(Variant::REAL, "base_light_value"), "set_base_light_value", "get_base_light_value");
ClassDB::bind_method(D_METHOD("get_uv_margin"), &PropMesher::get_uv_margin); ClassDB::bind_method(D_METHOD("get_uv_margin"), &PropMesher2D::get_uv_margin);
ClassDB::bind_method(D_METHOD("set_uv_margin", "value"), &PropMesher::set_uv_margin); ClassDB::bind_method(D_METHOD("set_uv_margin", "value"), &PropMesher2D::set_uv_margin);
ADD_PROPERTY(PropertyInfo(Variant::RECT2, "uv_margin"), "set_uv_margin", "get_uv_margin"); ADD_PROPERTY(PropertyInfo(Variant::RECT2, "uv_margin"), "set_uv_margin", "get_uv_margin");
ClassDB::bind_method(D_METHOD("get_build_flags"), &PropMesher::get_build_flags); ClassDB::bind_method(D_METHOD("get_build_flags"), &PropMesher2D::get_build_flags);
ClassDB::bind_method(D_METHOD("set_build_flags", "value"), &PropMesher::set_build_flags); ClassDB::bind_method(D_METHOD("set_build_flags", "value"), &PropMesher2D::set_build_flags);
ADD_PROPERTY(PropertyInfo(Variant::INT, "build_flags", PROPERTY_HINT_FLAGS, PropMesher::BINDING_STRING_BUILD_FLAGS), "set_build_flags", "get_build_flags"); ADD_PROPERTY(PropertyInfo(Variant::INT, "build_flags", PROPERTY_HINT_FLAGS, PropMesher2D::BINDING_STRING_BUILD_FLAGS), "set_build_flags", "get_build_flags");
ClassDB::bind_method(D_METHOD("add_tiled_wall_simple", "width", "height", "transform", "tiled_wall_data", "cache"), &PropMesher::add_tiled_wall_simple); ClassDB::bind_method(D_METHOD("add_tiled_wall_simple", "width", "height", "transform", "tiled_wall_data", "cache"), &PropMesher2D::add_tiled_wall_simple);
ClassDB::bind_method(D_METHOD("add_tiled_wall_mesh_rect_simple", "x", "y", "transform", "texture_rect"), &PropMesher::add_tiled_wall_mesh_rect_simple); ClassDB::bind_method(D_METHOD("add_tiled_wall_mesh_rect_simple", "x", "y", "transform", "texture_rect"), &PropMesher2D::add_tiled_wall_mesh_rect_simple);
ClassDB::bind_method(D_METHOD("transform_uv", "uv", "rect"), &PropMesher::transform_uv); ClassDB::bind_method(D_METHOD("transform_uv", "uv", "rect"), &PropMesher2D::transform_uv);
#ifdef MESH_DATA_RESOURCE_PRESENT #ifdef MESH_DATA_RESOURCE_PRESENT
ClassDB::bind_method(D_METHOD("add_mesh_data_resource", "mesh", "position", "rotation", "scale", "uv_rect"), &PropMesher::add_mesh_data_resource, DEFVAL(Rect2(0, 0, 1, 1)), DEFVAL(Vector3(1.0, 1.0, 1.0)), DEFVAL(Vector3()), DEFVAL(Vector3())); ClassDB::bind_method(D_METHOD("add_mesh_data_resource", "mesh", "position", "rotation", "scale", "uv_rect"), &PropMesher2D::add_mesh_data_resource, DEFVAL(Rect2(0, 0, 1, 1)), DEFVAL(Vector3(1.0, 1.0, 1.0)), DEFVAL(Vector3()), DEFVAL(Vector3()));
ClassDB::bind_method(D_METHOD("add_mesh_data_resource_transform", "mesh", "transform", "uv_rect"), &PropMesher::add_mesh_data_resource_transform, DEFVAL(Rect2(0, 0, 1, 1))); ClassDB::bind_method(D_METHOD("add_mesh_data_resource_transform", "mesh", "transform", "uv_rect"), &PropMesher2D::add_mesh_data_resource_transform, DEFVAL(Rect2(0, 0, 1, 1)));
ClassDB::bind_method(D_METHOD("add_mesh_data_resource_transform_colored", "mesh", "transform", "colors", "uv_rect"), &PropMesher::add_mesh_data_resource_transform_colored, DEFVAL(Rect2(0, 0, 1, 1))); ClassDB::bind_method(D_METHOD("add_mesh_data_resource_transform_colored", "mesh", "transform", "colors", "uv_rect"), &PropMesher2D::add_mesh_data_resource_transform_colored, DEFVAL(Rect2(0, 0, 1, 1)));
#endif #endif
ClassDB::bind_method(D_METHOD("generate_ao"), &PropMesher::generate_ao); ClassDB::bind_method(D_METHOD("generate_ao"), &PropMesher2D::generate_ao);
ClassDB::bind_method(D_METHOD("get_random_ao", "position"), &PropMesher::get_random_ao); ClassDB::bind_method(D_METHOD("get_random_ao", "position"), &PropMesher2D::get_random_ao);
BIND_VMETHOD(MethodInfo("_add_mesher", PropertyInfo(Variant::OBJECT, "mesher", PROPERTY_HINT_RESOURCE_TYPE, "PropMesher"))); BIND_VMETHOD(MethodInfo("_add_mesher", PropertyInfo(Variant::OBJECT, "mesher", PROPERTY_HINT_RESOURCE_TYPE, "PropMesher2D")));
ClassDB::bind_method(D_METHOD("add_mesher", "mesher"), &PropMesher::add_mesher); ClassDB::bind_method(D_METHOD("add_mesher", "mesher"), &PropMesher2D::add_mesher);
ClassDB::bind_method(D_METHOD("_add_mesher", "mesher"), &PropMesher::_add_mesher); ClassDB::bind_method(D_METHOD("_add_mesher", "mesher"), &PropMesher2D::_add_mesher);
ClassDB::bind_method(D_METHOD("add_light", "light"), &PropMesher::add_light); ClassDB::bind_method(D_METHOD("add_light", "light"), &PropMesher2D::add_light);
ClassDB::bind_method(D_METHOD("clear_lights"), &PropMesher::clear_lights); ClassDB::bind_method(D_METHOD("clear_lights"), &PropMesher2D::clear_lights);
ClassDB::bind_method(D_METHOD("get_vertices"), &PropMesher::get_vertices); ClassDB::bind_method(D_METHOD("get_vertices"), &PropMesher2D::get_vertices);
ClassDB::bind_method(D_METHOD("set_vertices", "values"), &PropMesher::set_vertices); ClassDB::bind_method(D_METHOD("set_vertices", "values"), &PropMesher2D::set_vertices);
ClassDB::bind_method(D_METHOD("get_vertex_count"), &PropMesher::get_vertex_count); ClassDB::bind_method(D_METHOD("get_vertex_count"), &PropMesher2D::get_vertex_count);
ClassDB::bind_method(D_METHOD("get_vertex", "idx"), &PropMesher::get_vertex); ClassDB::bind_method(D_METHOD("get_vertex", "idx"), &PropMesher2D::get_vertex);
ClassDB::bind_method(D_METHOD("remove_vertex", "idx"), &PropMesher::remove_vertex); ClassDB::bind_method(D_METHOD("remove_vertex", "idx"), &PropMesher2D::remove_vertex);
ClassDB::bind_method(D_METHOD("add_vertex", "vertex"), &PropMesher::add_vertex); ClassDB::bind_method(D_METHOD("add_vertex", "vertex"), &PropMesher2D::add_vertex);
ClassDB::bind_method(D_METHOD("get_normals"), &PropMesher::get_normals); ClassDB::bind_method(D_METHOD("get_normals"), &PropMesher2D::get_normals);
ClassDB::bind_method(D_METHOD("set_normals", "values"), &PropMesher::set_normals); ClassDB::bind_method(D_METHOD("set_normals", "values"), &PropMesher2D::set_normals);
ClassDB::bind_method(D_METHOD("get_normal", "idx"), &PropMesher::get_normal); ClassDB::bind_method(D_METHOD("get_normal", "idx"), &PropMesher2D::get_normal);
ClassDB::bind_method(D_METHOD("add_normal", "normal"), &PropMesher::add_normal); ClassDB::bind_method(D_METHOD("add_normal", "normal"), &PropMesher2D::add_normal);
ClassDB::bind_method(D_METHOD("get_colors"), &PropMesher::get_colors); ClassDB::bind_method(D_METHOD("get_colors"), &PropMesher2D::get_colors);
ClassDB::bind_method(D_METHOD("set_colors", "values"), &PropMesher::set_colors); ClassDB::bind_method(D_METHOD("set_colors", "values"), &PropMesher2D::set_colors);
ClassDB::bind_method(D_METHOD("get_color", "idx"), &PropMesher::get_color); ClassDB::bind_method(D_METHOD("get_color", "idx"), &PropMesher2D::get_color);
ClassDB::bind_method(D_METHOD("add_color", "color"), &PropMesher::add_color); ClassDB::bind_method(D_METHOD("add_color", "color"), &PropMesher2D::add_color);
ClassDB::bind_method(D_METHOD("get_uvs"), &PropMesher::get_uvs); ClassDB::bind_method(D_METHOD("get_uvs"), &PropMesher2D::get_uvs);
ClassDB::bind_method(D_METHOD("set_uvs", "values"), &PropMesher::set_uvs); ClassDB::bind_method(D_METHOD("set_uvs", "values"), &PropMesher2D::set_uvs);
ClassDB::bind_method(D_METHOD("get_uv", "idx"), &PropMesher::get_uv); ClassDB::bind_method(D_METHOD("get_uv", "idx"), &PropMesher2D::get_uv);
ClassDB::bind_method(D_METHOD("add_uv", "uv"), &PropMesher::add_uv); ClassDB::bind_method(D_METHOD("add_uv", "uv"), &PropMesher2D::add_uv);
ClassDB::bind_method(D_METHOD("get_uv2s"), &PropMesher::get_uv2s); ClassDB::bind_method(D_METHOD("get_uv2s"), &PropMesher2D::get_uv2s);
ClassDB::bind_method(D_METHOD("set_uv2s", "values"), &PropMesher::set_uv2s); ClassDB::bind_method(D_METHOD("set_uv2s", "values"), &PropMesher2D::set_uv2s);
ClassDB::bind_method(D_METHOD("get_uv2", "idx"), &PropMesher::get_uv2); ClassDB::bind_method(D_METHOD("get_uv2", "idx"), &PropMesher2D::get_uv2);
ClassDB::bind_method(D_METHOD("add_uv2", "uv"), &PropMesher::add_uv2); ClassDB::bind_method(D_METHOD("add_uv2", "uv"), &PropMesher2D::add_uv2);
ClassDB::bind_method(D_METHOD("get_indices"), &PropMesher::get_indices); ClassDB::bind_method(D_METHOD("get_indices"), &PropMesher2D::get_indices);
ClassDB::bind_method(D_METHOD("set_indices", "values"), &PropMesher::set_indices); ClassDB::bind_method(D_METHOD("set_indices", "values"), &PropMesher2D::set_indices);
ClassDB::bind_method(D_METHOD("get_indices_count"), &PropMesher::get_indices_count); ClassDB::bind_method(D_METHOD("get_indices_count"), &PropMesher2D::get_indices_count);
ClassDB::bind_method(D_METHOD("get_index", "idx"), &PropMesher::get_index); ClassDB::bind_method(D_METHOD("get_index", "idx"), &PropMesher2D::get_index);
ClassDB::bind_method(D_METHOD("remove_index", "idx"), &PropMesher::remove_index); ClassDB::bind_method(D_METHOD("remove_index", "idx"), &PropMesher2D::remove_index);
ClassDB::bind_method(D_METHOD("add_indices", "indice"), &PropMesher::add_indices); ClassDB::bind_method(D_METHOD("add_indices", "indice"), &PropMesher2D::add_indices);
ClassDB::bind_method(D_METHOD("reset"), &PropMesher::reset); ClassDB::bind_method(D_METHOD("reset"), &PropMesher2D::reset);
//ClassDB::bind_method(D_METHOD("calculate_vertex_ambient_occlusion", "meshinstance_path", "radius", "intensity", "sampleCount"), &PropMesher::calculate_vertex_ambient_occlusion_path); //ClassDB::bind_method(D_METHOD("calculate_vertex_ambient_occlusion", "meshinstance_path", "radius", "intensity", "sampleCount"), &PropMesher2D::calculate_vertex_ambient_occlusion_path);
ClassDB::bind_method(D_METHOD("build_mesh"), &PropMesher::build_mesh); ClassDB::bind_method(D_METHOD("build_mesh"), &PropMesher2D::build_mesh);
ClassDB::bind_method(D_METHOD("build_mesh_into", "mesh_rid"), &PropMesher::build_mesh_into); ClassDB::bind_method(D_METHOD("build_mesh_into", "mesh_rid"), &PropMesher2D::build_mesh_into);
ClassDB::bind_method(D_METHOD("build_collider"), &PropMesher::build_collider); ClassDB::bind_method(D_METHOD("build_collider"), &PropMesher2D::build_collider);
ClassDB::bind_method(D_METHOD("bake_colors"), &PropMesher::bake_colors); ClassDB::bind_method(D_METHOD("bake_colors"), &PropMesher2D::bake_colors);
ClassDB::bind_method(D_METHOD("generate_normals", "flip"), &PropMesher::generate_normals, DEFVAL(false)); ClassDB::bind_method(D_METHOD("generate_normals", "flip"), &PropMesher2D::generate_normals, DEFVAL(false));
ClassDB::bind_method(D_METHOD("remove_doubles"), &PropMesher::remove_doubles); ClassDB::bind_method(D_METHOD("remove_doubles"), &PropMesher2D::remove_doubles);
ClassDB::bind_method(D_METHOD("remove_doubles_hashed"), &PropMesher::remove_doubles_hashed); ClassDB::bind_method(D_METHOD("remove_doubles_hashed"), &PropMesher2D::remove_doubles_hashed);
} }

26
prop_mesher_2d.h
View File

@ -61,12 +61,12 @@ using PoolVector = Vector<N>;
#endif #endif
class OpenSimplexNoise; class OpenSimplexNoise;
class PropLight; class PropLight2D;
class PropMaterialCache; class PropMaterialCache2D;
class TiledWallData; class TiledWallData2D;
class PropMesher : public Reference { class PropMesher2D : public Reference {
GDCLASS(PropMesher, Reference); GDCLASS(PropMesher2D, Reference);
public: public:
static const String BINDING_STRING_BUILD_FLAGS; static const String BINDING_STRING_BUILD_FLAGS;
@ -145,7 +145,7 @@ public:
void reset(); void reset();
void add_tiled_wall_simple(const int width, const int height, const Transform &transform, const Ref<TiledWallData> &tiled_wall_data, Ref<PropMaterialCache> cache); void add_tiled_wall_simple(const int width, const int height, const Transform &transform, const Ref<TiledWallData2D> &tiled_wall_data, Ref<PropMaterialCache2D> cache);
void add_tiled_wall_mesh_rect_simple(const int x, const int y, const Transform &transform, const Rect2 &texture_rect); void add_tiled_wall_mesh_rect_simple(const int x, const int y, const Transform &transform, const Rect2 &texture_rect);
Vector2 transform_uv(const Vector2 &uv, const Rect2 &rect) const; Vector2 transform_uv(const Vector2 &uv, const Rect2 &rect) const;
@ -159,10 +159,10 @@ public:
float get_random_ao(const Vector3 &position); float get_random_ao(const Vector3 &position);
Color get_light_color_at(const Vector3 &position, const Vector3 &normal); Color get_light_color_at(const Vector3 &position, const Vector3 &normal);
void add_mesher(const Ref<PropMesher> &mesher); void add_mesher(const Ref<PropMesher2D> &mesher);
void _add_mesher(const Ref<PropMesher> &mesher); void _add_mesher(const Ref<PropMesher2D> &mesher);
void add_light(const Ref<PropLight> &light); void add_light(const Ref<PropLight2D> &light);
void clear_lights(); void clear_lights();
PoolVector<Vector3> build_collider() const; PoolVector<Vector3> build_collider() const;
@ -217,8 +217,8 @@ public:
void remove_index(const int idx); void remove_index(const int idx);
void add_indices(const int index); void add_indices(const int index);
PropMesher(); PropMesher2D();
~PropMesher(); ~PropMesher2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();
@ -234,7 +234,7 @@ protected:
PoolVector<Vertex> _vertices; PoolVector<Vertex> _vertices;
PoolVector<int> _indices; PoolVector<int> _indices;
Vector<Ref<PropLight>> _lights; Vector<Ref<PropLight2D>> _lights;
Color _last_color; Color _last_color;
Vector3 _last_normal; Vector3 _last_normal;
@ -258,6 +258,6 @@ protected:
int _rao_seed; int _rao_seed;
}; };
VARIANT_ENUM_CAST(PropMesher::BuildFlags); VARIANT_ENUM_CAST(PropMesher2D::BuildFlags);
#endif #endif

36
prop_scene_instance_2d.cpp
View File

@ -8,10 +8,10 @@
#include "core/engine.h" #include "core/engine.h"
#endif #endif
Ref<PackedScene> PropSceneInstance::get_scene() { Ref<PackedScene> PropSceneInstance2D::get_scene() {
return _scene; return _scene;
} }
void PropSceneInstance::set_scene(const Ref<PackedScene> &data) { void PropSceneInstance2D::set_scene(const Ref<PackedScene> &data) {
if (_scene == data) if (_scene == data)
return; return;
@ -20,21 +20,21 @@ void PropSceneInstance::set_scene(const Ref<PackedScene> &data) {
build(); build();
} }
bool PropSceneInstance::get_snap_to_mesh() const { bool PropSceneInstance2D::get_snap_to_mesh() const {
return _snap_to_mesh; return _snap_to_mesh;
} }
void PropSceneInstance::set_snap_to_mesh(const bool value) { void PropSceneInstance2D::set_snap_to_mesh(const bool value) {
_snap_to_mesh = value; _snap_to_mesh = value;
} }
Vector3 PropSceneInstance::get_snap_axis() const { Vector3 PropSceneInstance2D::get_snap_axis() const {
return _snap_axis; return _snap_axis;
} }
void PropSceneInstance::set_snap_axis(const Vector3 &value) { void PropSceneInstance2D::set_snap_axis(const Vector3 &value) {
_snap_axis = value; _snap_axis = value;
} }
void PropSceneInstance::build() { void PropSceneInstance2D::build() {
if (!is_inside_tree()) { if (!is_inside_tree()) {
return; return;
} }
@ -59,15 +59,15 @@ void PropSceneInstance::build() {
// n->set_owner(get_tree()->get_edited_scene_root()); // n->set_owner(get_tree()->get_edited_scene_root());
} }
PropSceneInstance::PropSceneInstance() { PropSceneInstance2D::PropSceneInstance2D() {
_snap_to_mesh = false; _snap_to_mesh = false;
_snap_axis = Vector3(0, -1, 0); _snap_axis = Vector3(0, -1, 0);
} }
PropSceneInstance::~PropSceneInstance() { PropSceneInstance2D::~PropSceneInstance2D() {
_scene.unref(); _scene.unref();
} }
void PropSceneInstance::_notification(int p_what) { void PropSceneInstance2D::_notification(int p_what) {
switch (p_what) { switch (p_what) {
case NOTIFICATION_ENTER_TREE: { case NOTIFICATION_ENTER_TREE: {
build(); build();
@ -75,18 +75,18 @@ void PropSceneInstance::_notification(int p_what) {
} }
} }
void PropSceneInstance::_bind_methods() { void PropSceneInstance2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_scene"), &PropSceneInstance::get_scene); ClassDB::bind_method(D_METHOD("get_scene"), &PropSceneInstance2D::get_scene);
ClassDB::bind_method(D_METHOD("set_scene", "value"), &PropSceneInstance::set_scene); ClassDB::bind_method(D_METHOD("set_scene", "value"), &PropSceneInstance2D::set_scene);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "scene", PROPERTY_HINT_RESOURCE_TYPE, "PackedScene"), "set_scene", "get_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"), &PropSceneInstance::get_snap_to_mesh); ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropSceneInstance2D::get_snap_to_mesh);
ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropSceneInstance::set_snap_to_mesh); ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropSceneInstance2D::set_snap_to_mesh);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_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"), &PropSceneInstance::get_snap_axis); ClassDB::bind_method(D_METHOD("get_snap_axis"), &PropSceneInstance2D::get_snap_axis);
ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropSceneInstance::set_snap_axis); ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropSceneInstance2D::set_snap_axis);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis"); ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis");
ClassDB::bind_method(D_METHOD("build"), &PropSceneInstance::build); ClassDB::bind_method(D_METHOD("build"), &PropSceneInstance2D::build);
} }

8
prop_scene_instance_2d.h
View File

@ -38,8 +38,8 @@ SOFTWARE.
#include "props/prop_data_2d.h" #include "props/prop_data_2d.h"
#include "scene/resources/packed_scene.h" #include "scene/resources/packed_scene.h"
class PropSceneInstance : public Spatial { class PropSceneInstance2D : public Spatial {
GDCLASS(PropSceneInstance, Spatial); GDCLASS(PropSceneInstance2D, Spatial);
public: public:
Ref<PackedScene> get_scene(); Ref<PackedScene> get_scene();
@ -53,8 +53,8 @@ public:
void build(); void build();
PropSceneInstance(); PropSceneInstance2D();
~PropSceneInstance(); ~PropSceneInstance2D();
protected: protected:
void _notification(int p_what); void _notification(int p_what);

86
props/prop_data_2d.cpp
View File

@ -34,51 +34,51 @@ SOFTWARE.
#define Shape Shape3D #define Shape Shape3D
#endif #endif
int PropData::get_id() const { int PropData2D::get_id() const {
return _id; return _id;
} }
void PropData::set_id(const int value) { void PropData2D::set_id(const int value) {
_id = value; _id = value;
} }
bool PropData::get_snap_to_mesh() const { bool PropData2D::get_snap_to_mesh() const {
return _snap_to_mesh; return _snap_to_mesh;
} }
void PropData::set_snap_to_mesh(const bool value) { void PropData2D::set_snap_to_mesh(const bool value) {
_snap_to_mesh = value; _snap_to_mesh = value;
} }
Vector3 PropData::get_snap_axis() const { Vector3 PropData2D::get_snap_axis() const {
return _snap_axis; return _snap_axis;
} }
void PropData::set_snap_axis(const Vector3 &value) { void PropData2D::set_snap_axis(const Vector3 &value) {
_snap_axis = value; _snap_axis = value;
} }
Ref<PropDataEntry> PropData::get_prop(const int index) const { Ref<PropDataEntry2D> PropData2D::get_prop(const int index) const {
ERR_FAIL_INDEX_V(index, _props.size(), Ref<PropDataEntry>()); ERR_FAIL_INDEX_V(index, _props.size(), Ref<PropDataEntry2D>());
return _props.get(index); return _props.get(index);
} }
void PropData::set_prop(const int index, const Ref<PropDataEntry> prop) { void PropData2D::set_prop(const int index, const Ref<PropDataEntry2D> prop) {
ERR_FAIL_INDEX(index, _props.size()); ERR_FAIL_INDEX(index, _props.size());
_props.set(index, prop); _props.set(index, prop);
} }
void PropData::add_prop(const Ref<PropDataEntry> prop) { void PropData2D::add_prop(const Ref<PropDataEntry2D> prop) {
_props.push_back(prop); _props.push_back(prop);
} }
void PropData::remove_prop(const int index) { void PropData2D::remove_prop(const int index) {
ERR_FAIL_INDEX(index, _props.size()); ERR_FAIL_INDEX(index, _props.size());
_props.remove(index); _props.remove(index);
} }
int PropData::get_prop_count() const { int PropData2D::get_prop_count() const {
return _props.size(); return _props.size();
} }
Vector<Variant> PropData::get_props() { Vector<Variant> PropData2D::get_props() {
Vector<Variant> r; Vector<Variant> r;
for (int i = 0; i < _props.size(); i++) { for (int i = 0; i < _props.size(); i++) {
#if VERSION_MAJOR < 4 #if VERSION_MAJOR < 4
@ -89,21 +89,21 @@ Vector<Variant> PropData::get_props() {
} }
return r; return r;
} }
void PropData::set_props(const Vector<Variant> &props) { void PropData2D::set_props(const Vector<Variant> &props) {
_props.clear(); _props.clear();
for (int i = 0; i < props.size(); i++) { for (int i = 0; i < props.size(); i++) {
Ref<PropDataEntry> prop = Ref<PropDataEntry>(props[i]); Ref<PropDataEntry2D> prop = Ref<PropDataEntry2D>(props[i]);
_props.push_back(prop); _props.push_back(prop);
} }
} }
#if TEXTURE_PACKER_PRESENT #if TEXTURE_PACKER_PRESENT
void PropData::add_textures_into(Ref<TexturePacker> texture_packer) { void PropData2D::add_textures_into(Ref<TexturePacker> texture_packer) {
ERR_FAIL_COND(!texture_packer.is_valid()); ERR_FAIL_COND(!texture_packer.is_valid());
for (int i = 0; i < _props.size(); ++i) { for (int i = 0; i < _props.size(); ++i) {
Ref<PropDataEntry> entry = _props.get(i); Ref<PropDataEntry2D> entry = _props.get(i);
if (entry.is_valid()) { if (entry.is_valid()) {
entry->add_textures_into(texture_packer); entry->add_textures_into(texture_packer);
@ -112,21 +112,21 @@ void PropData::add_textures_into(Ref<TexturePacker> texture_packer) {
} }
#endif #endif
bool PropData::get_is_room() const { bool PropData2D::get_is_room() const {
return _is_room; return _is_room;
} }
void PropData::set_is_room(const bool value) { void PropData2D::set_is_room(const bool value) {
_is_room = value; _is_room = value;
} }
PoolVector3Array PropData::get_room_bounds() { PoolVector3Array PropData2D::get_room_bounds() {
return _room_bounds; return _room_bounds;
} }
void PropData::set_room_bounds(const PoolVector3Array &bounds) { void PropData2D::set_room_bounds(const PoolVector3Array &bounds) {
_room_bounds = bounds; _room_bounds = bounds;
} }
void PropData::copy_from(const Ref<PropData> &prop_data) { void PropData2D::copy_from(const Ref<PropData2D> &prop_data) {
_id = prop_data->_id; _id = prop_data->_id;
_snap_to_mesh = prop_data->_snap_to_mesh; _snap_to_mesh = prop_data->_snap_to_mesh;
_snap_axis = prop_data->_snap_axis; _snap_axis = prop_data->_snap_axis;
@ -143,47 +143,47 @@ void PropData::copy_from(const Ref<PropData> &prop_data) {
emit_changed(); emit_changed();
} }
PropData::PropData() { PropData2D::PropData2D() {
_id = 0; _id = 0;
_snap_to_mesh = false; _snap_to_mesh = false;
_is_room = false; _is_room = false;
_snap_axis = Vector3(0, -1, 0); _snap_axis = Vector3(0, -1, 0);
} }
PropData::~PropData() { PropData2D::~PropData2D() {
_props.clear(); _props.clear();
} }
void PropData::_bind_methods() { void PropData2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropData::get_snap_to_mesh); ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropData2D::get_snap_to_mesh);
ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropData::set_snap_to_mesh); ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropData2D::set_snap_to_mesh);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_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("get_snap_axis"), &PropData2D::get_snap_axis);
ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropData::set_snap_axis); ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropData2D::set_snap_axis);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_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("get_prop", "index"), &PropData2D::get_prop);
ClassDB::bind_method(D_METHOD("set_prop", "index", "spell"), &PropData::set_prop); ClassDB::bind_method(D_METHOD("set_prop", "index", "spell"), &PropData2D::set_prop);
ClassDB::bind_method(D_METHOD("add_prop", "prop"), &PropData::add_prop); ClassDB::bind_method(D_METHOD("add_prop", "prop"), &PropData2D::add_prop);
ClassDB::bind_method(D_METHOD("remove_prop", "index"), &PropData::remove_prop); ClassDB::bind_method(D_METHOD("remove_prop", "index"), &PropData2D::remove_prop);
ClassDB::bind_method(D_METHOD("get_prop_count"), &PropData::get_prop_count); ClassDB::bind_method(D_METHOD("get_prop_count"), &PropData2D::get_prop_count);
ClassDB::bind_method(D_METHOD("get_props"), &PropData::get_props); ClassDB::bind_method(D_METHOD("get_props"), &PropData2D::get_props);
ClassDB::bind_method(D_METHOD("set_props", "props"), &PropData::set_props); ClassDB::bind_method(D_METHOD("set_props", "props"), &PropData2D::set_props);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "props", PROPERTY_HINT_NONE, "17/17:PropDataEntry", PROPERTY_USAGE_DEFAULT, "PropDataEntry"), "set_props", "get_props"); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "props", PROPERTY_HINT_NONE, "17/17:PropDataEntry2D", PROPERTY_USAGE_DEFAULT, "PropDataEntry2D"), "set_props", "get_props");
#if TEXTURE_PACKER_PRESENT #if TEXTURE_PACKER_PRESENT
ClassDB::bind_method(D_METHOD("add_textures_into", "texture_packer"), &PropData::add_textures_into); ClassDB::bind_method(D_METHOD("add_textures_into", "texture_packer"), &PropData2D::add_textures_into);
#endif #endif
ClassDB::bind_method(D_METHOD("get_is_room"), &PropData::get_is_room); ClassDB::bind_method(D_METHOD("get_is_room"), &PropData2D::get_is_room);
ClassDB::bind_method(D_METHOD("set_is_room", "value"), &PropData::set_is_room); ClassDB::bind_method(D_METHOD("set_is_room", "value"), &PropData2D::set_is_room);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "is_room"), "set_is_room", "get_is_room"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "is_room"), "set_is_room", "get_is_room");
ClassDB::bind_method(D_METHOD("get_room_bounds"), &PropData::get_room_bounds); ClassDB::bind_method(D_METHOD("get_room_bounds"), &PropData2D::get_room_bounds);
ClassDB::bind_method(D_METHOD("set_room_bounds", "value"), &PropData::set_room_bounds); ClassDB::bind_method(D_METHOD("set_room_bounds", "value"), &PropData2D::set_room_bounds);
ADD_PROPERTY(PropertyInfo(Variant::POOL_VECTOR3_ARRAY, "room_bounds"), "set_room_bounds", "get_room_bounds"); ADD_PROPERTY(PropertyInfo(Variant::POOL_VECTOR3_ARRAY, "room_bounds"), "set_room_bounds", "get_room_bounds");
ClassDB::bind_method(D_METHOD("copy_from", "prop_data"), &PropData::copy_from); ClassDB::bind_method(D_METHOD("copy_from", "prop_data"), &PropData2D::copy_from);
} }

18
props/prop_data_2d.h
View File

@ -46,8 +46,8 @@ SOFTWARE.
#include "../../texture_packer/texture_packer.h" #include "../../texture_packer/texture_packer.h"
#endif #endif
class PropData : public Resource { class PropData2D : public Resource {
GDCLASS(PropData, Resource); GDCLASS(PropData2D, Resource);
public: public:
int get_id() const; int get_id() const;
@ -59,9 +59,9 @@ public:
Vector3 get_snap_axis() const; Vector3 get_snap_axis() const;
void set_snap_axis(const Vector3 &value); void set_snap_axis(const Vector3 &value);
Ref<PropDataEntry> get_prop(const int index) const; Ref<PropDataEntry2D> get_prop(const int index) const;
void set_prop(const int index, const Ref<PropDataEntry> prop); void set_prop(const int index, const Ref<PropDataEntry2D> prop);
void add_prop(const Ref<PropDataEntry> prop); void add_prop(const Ref<PropDataEntry2D> prop);
void remove_prop(const int index); void remove_prop(const int index);
int get_prop_count() const; int get_prop_count() const;
@ -79,10 +79,10 @@ public:
PoolVector3Array get_room_bounds(); PoolVector3Array get_room_bounds();
void set_room_bounds(const PoolVector3Array &bounds); void set_room_bounds(const PoolVector3Array &bounds);
void copy_from(const Ref<PropData> &prop_data); void copy_from(const Ref<PropData2D> &prop_data);
PropData(); PropData2D();
~PropData(); ~PropData2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();
@ -92,7 +92,7 @@ private:
bool _snap_to_mesh; bool _snap_to_mesh;
Vector3 _snap_axis; Vector3 _snap_axis;
Vector<Ref<PropDataEntry>> _props; Vector<Ref<PropDataEntry2D>> _props;
bool _is_room; bool _is_room;
PoolVector3Array _room_bounds; PoolVector3Array _room_bounds;

52
props/prop_data_entry_2d.cpp
View File

@ -40,64 +40,64 @@ SOFTWARE.
#include "../prop_mesher_2d.h" #include "../prop_mesher_2d.h"
Transform PropDataEntry::get_transform() const { Transform PropDataEntry2D::get_transform() const {
return _transform; return _transform;
} }
void PropDataEntry::set_transform(const Transform &value) { void PropDataEntry2D::set_transform(const Transform &value) {
_transform = value; _transform = value;
} }
#if TEXTURE_PACKER_PRESENT #if TEXTURE_PACKER_PRESENT
void PropDataEntry::add_textures_into(Ref<TexturePacker> texture_packer) { void PropDataEntry2D::add_textures_into(Ref<TexturePacker> texture_packer) {
if (has_method("_add_textures_into")) if (has_method("_add_textures_into"))
call("_add_textures_into", texture_packer); call("_add_textures_into", texture_packer);
} }
#endif #endif
bool PropDataEntry::processor_handles(Node *node) { bool PropDataEntry2D::processor_handles(Node *node) {
return call("_processor_handles", node); return call("_processor_handles", node);
} }
void PropDataEntry::processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform) { void PropDataEntry2D::processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform) {
call("_processor_process", prop_data, node, transform); call("_processor_process", prop_data, node, transform);
} }
Node *PropDataEntry::processor_get_node_for(const Transform &transform) { Node *PropDataEntry2D::processor_get_node_for(const Transform &transform) {
return call("_processor_get_node_for", transform); return call("_processor_get_node_for", transform);
} }
bool PropDataEntry::processor_evaluate_children() { bool PropDataEntry2D::processor_evaluate_children() {
return call("_processor_evaluate_children"); return call("_processor_evaluate_children");
} }
bool PropDataEntry::_processor_handles(Node *node) { bool PropDataEntry2D::_processor_handles(Node *node) {
return false; return false;
} }
void PropDataEntry::_processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform) { void PropDataEntry2D::_processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform) {
} }
Node *PropDataEntry::_processor_get_node_for(const Transform &transform) { Node *PropDataEntry2D::_processor_get_node_for(const Transform &transform) {
return NULL; return NULL;
} }
bool PropDataEntry::_processor_evaluate_children() { bool PropDataEntry2D::_processor_evaluate_children() {
return true; return true;
} }
PropDataEntry::PropDataEntry() { PropDataEntry2D::PropDataEntry2D() {
} }
PropDataEntry::~PropDataEntry() { PropDataEntry2D::~PropDataEntry2D() {
} }
void PropDataEntry::_bind_methods() { void PropDataEntry2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_transform"), &PropDataEntry::get_transform); ClassDB::bind_method(D_METHOD("get_transform"), &PropDataEntry2D::get_transform);
ClassDB::bind_method(D_METHOD("set_transform", "value"), &PropDataEntry::set_transform); ClassDB::bind_method(D_METHOD("set_transform", "value"), &PropDataEntry2D::set_transform);
ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM, "transform"), "set_transform", "get_transform"); ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM, "transform"), "set_transform", "get_transform");
#if TEXTURE_PACKER_PRESENT #if TEXTURE_PACKER_PRESENT
BIND_VMETHOD(MethodInfo("_add_textures_into", PropertyInfo(Variant::OBJECT, "texture_packer", PROPERTY_HINT_RESOURCE_TYPE, "TexturePacker"))); BIND_VMETHOD(MethodInfo("_add_textures_into", PropertyInfo(Variant::OBJECT, "texture_packer", PROPERTY_HINT_RESOURCE_TYPE, "TexturePacker")));
ClassDB::bind_method(D_METHOD("add_textures_into", "texture_packer"), &PropDataEntry::add_textures_into); ClassDB::bind_method(D_METHOD("add_textures_into", "texture_packer"), &PropDataEntry2D::add_textures_into);
#endif #endif
BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::BOOL, "handles"), "_processor_handles")); BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::BOOL, "handles"), "_processor_handles"));
BIND_VMETHOD(MethodInfo("_processor_process", BIND_VMETHOD(MethodInfo("_processor_process",
PropertyInfo(Variant::OBJECT, "prop_data", PROPERTY_HINT_RESOURCE_TYPE, "PropData"), PropertyInfo(Variant::OBJECT, "prop_data", PROPERTY_HINT_RESOURCE_TYPE, "PropData2D"),
PropertyInfo(Variant::OBJECT, "node", PROPERTY_HINT_RESOURCE_TYPE, "Node"), PropertyInfo(Variant::OBJECT, "node", PROPERTY_HINT_RESOURCE_TYPE, "Node"),
PropertyInfo(Variant::TRANSFORM, "transform"))); PropertyInfo(Variant::TRANSFORM, "transform")));
@ -106,14 +106,14 @@ void PropDataEntry::_bind_methods() {
BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::BOOL, "evaluate"), "_processor_evaluate_children")); BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::BOOL, "evaluate"), "_processor_evaluate_children"));
ClassDB::bind_method(D_METHOD("processor_handles", "node"), &PropDataEntry::processor_handles); ClassDB::bind_method(D_METHOD("processor_handles", "node"), &PropDataEntry2D::processor_handles);
ClassDB::bind_method(D_METHOD("processor_process", "prop_data", "node", "transform"), &PropDataEntry::processor_process); ClassDB::bind_method(D_METHOD("processor_process", "prop_data", "node", "transform"), &PropDataEntry2D::processor_process);
ClassDB::bind_method(D_METHOD("processor_get_node_for", "prop_data"), &PropDataEntry::processor_get_node_for); ClassDB::bind_method(D_METHOD("processor_get_node_for", "prop_data"), &PropDataEntry2D::processor_get_node_for);
ClassDB::bind_method(D_METHOD("processor_evaluate_children"), &PropDataEntry::processor_evaluate_children); ClassDB::bind_method(D_METHOD("processor_evaluate_children"), &PropDataEntry2D::processor_evaluate_children);
ClassDB::bind_method(D_METHOD("_processor_handles", "node"), &PropDataEntry::_processor_handles); ClassDB::bind_method(D_METHOD("_processor_handles", "node"), &PropDataEntry2D::_processor_handles);
ClassDB::bind_method(D_METHOD("_processor_process", "prop_data", "node", "transform"), &PropDataEntry::_processor_process); ClassDB::bind_method(D_METHOD("_processor_process", "prop_data", "node", "transform"), &PropDataEntry2D::_processor_process);
ClassDB::bind_method(D_METHOD("_processor_get_node_for", "transform"), &PropDataEntry::_processor_get_node_for); ClassDB::bind_method(D_METHOD("_processor_get_node_for", "transform"), &PropDataEntry2D::_processor_get_node_for);
ClassDB::bind_method(D_METHOD("_processor_evaluate_children"), &PropDataEntry::_processor_evaluate_children); ClassDB::bind_method(D_METHOD("_processor_evaluate_children"), &PropDataEntry2D::_processor_evaluate_children);
} }

16
props/prop_data_entry_2d.h
View File

@ -33,12 +33,12 @@ SOFTWARE.
#include "core/math/transform.h" #include "core/math/transform.h"
class PropData; class PropData2D;
class PropMesher; class PropMesher2D;
class TexturePacker; class TexturePacker;
class PropDataEntry : public Resource { class PropDataEntry2D : public Resource {
GDCLASS(PropDataEntry, Resource); GDCLASS(PropDataEntry2D, Resource);
public: public:
Transform get_transform() const; Transform get_transform() const;
@ -49,17 +49,17 @@ public:
#endif #endif
bool processor_handles(Node *node); bool processor_handles(Node *node);
void processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform); void processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform);
Node *processor_get_node_for(const Transform &transform); Node *processor_get_node_for(const Transform &transform);
bool processor_evaluate_children(); bool processor_evaluate_children();
virtual bool _processor_handles(Node *node); virtual bool _processor_handles(Node *node);
virtual void _processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform); virtual void _processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform);
virtual Node *_processor_get_node_for(const Transform &transform); virtual Node *_processor_get_node_for(const Transform &transform);
virtual bool _processor_evaluate_children(); virtual bool _processor_evaluate_children();
PropDataEntry(); PropDataEntry2D();
~PropDataEntry(); ~PropDataEntry2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();

30
props/prop_data_light_2d.cpp
View File

@ -32,32 +32,32 @@ SOFTWARE.
#define Light Light3D #define Light Light3D
#endif #endif
Color PropDataLight::get_light_color() const { Color PropDataLight2D::get_light_color() const {
return _light_color; return _light_color;
} }
void PropDataLight::set_light_color(const Color value) { void PropDataLight2D::set_light_color(const Color value) {
_light_color = value; _light_color = value;
} }
int PropDataLight::get_light_size() const { int PropDataLight2D::get_light_size() const {
return _light_size; return _light_size;
} }
void PropDataLight::set_light_size(const int value) { void PropDataLight2D::set_light_size(const int value) {
_light_size = value; _light_size = value;
} }
bool PropDataLight::_processor_handles(Node *node) { bool PropDataLight2D::_processor_handles(Node *node) {
OmniLight *i = Object::cast_to<OmniLight>(node); OmniLight *i = Object::cast_to<OmniLight>(node);
return i; return i;
} }
void PropDataLight::_processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform) { void PropDataLight2D::_processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform) {
OmniLight *i = Object::cast_to<OmniLight>(node); OmniLight *i = Object::cast_to<OmniLight>(node);
ERR_FAIL_COND(!i); ERR_FAIL_COND(!i);
Ref<PropDataLight> l; Ref<PropDataLight2D> l;
l.instance(); l.instance();
l->set_light_color(i->get_color()); l->set_light_color(i->get_color());
l->set_light_size(i->get_param(Light::PARAM_RANGE)); l->set_light_size(i->get_param(Light::PARAM_RANGE));
@ -65,7 +65,7 @@ void PropDataLight::_processor_process(Ref<PropData> prop_data, Node *node, cons
prop_data->add_prop(l); prop_data->add_prop(l);
} }
Node *PropDataLight::_processor_get_node_for(const Transform &transform) { Node *PropDataLight2D::_processor_get_node_for(const Transform &transform) {
OmniLight *i = memnew(OmniLight); OmniLight *i = memnew(OmniLight);
i->set_color(get_light_color()); i->set_color(get_light_color());
@ -75,18 +75,18 @@ Node *PropDataLight::_processor_get_node_for(const Transform &transform) {
return i; return i;
} }
PropDataLight::PropDataLight() { PropDataLight2D::PropDataLight2D() {
_light_size = 0; _light_size = 0;
} }
PropDataLight::~PropDataLight() { PropDataLight2D::~PropDataLight2D() {
} }
void PropDataLight::_bind_methods() { void PropDataLight2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_light_color"), &PropDataLight::get_light_color); ClassDB::bind_method(D_METHOD("get_light_color"), &PropDataLight2D::get_light_color);
ClassDB::bind_method(D_METHOD("set_light_color", "value"), &PropDataLight::set_light_color); ClassDB::bind_method(D_METHOD("set_light_color", "value"), &PropDataLight2D::set_light_color);
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "light_color"), "set_light_color", "get_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("get_light_size"), &PropDataLight2D::get_light_size);
ClassDB::bind_method(D_METHOD("set_light_size", "value"), &PropDataLight::set_light_size); ClassDB::bind_method(D_METHOD("set_light_size", "value"), &PropDataLight2D::set_light_size);
ADD_PROPERTY(PropertyInfo(Variant::INT, "light_size"), "set_light_size", "get_light_size"); ADD_PROPERTY(PropertyInfo(Variant::INT, "light_size"), "set_light_size", "get_light_size");
} }

10
props/prop_data_light_2d.h
View File

@ -33,8 +33,8 @@ SOFTWARE.
#include "prop_data_entry_2d.h" #include "prop_data_entry_2d.h"
class PropDataLight : public PropDataEntry { class PropDataLight2D : public PropDataEntry2D {
GDCLASS(PropDataLight, PropDataEntry); GDCLASS(PropDataLight2D, PropDataEntry2D);
public: public:
Color get_light_color() const; Color get_light_color() const;
@ -44,11 +44,11 @@ public:
void set_light_size(const int value); void set_light_size(const int value);
bool _processor_handles(Node *node); bool _processor_handles(Node *node);
void _processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform); void _processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform);
Node *_processor_get_node_for(const Transform &transform); Node *_processor_get_node_for(const Transform &transform);
PropDataLight(); PropDataLight2D();
~PropDataLight(); ~PropDataLight2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();

54
props/prop_data_portal_2d.cpp
View File

@ -26,53 +26,53 @@ SOFTWARE.
#include "scene/3d/portal.h" #include "scene/3d/portal.h"
bool PropDataPortal::get_is_active() const { bool PropDataPortal2D::get_is_active() const {
return _is_active; return _is_active;
} }
void PropDataPortal::set_is_active(bool p_active) { void PropDataPortal2D::set_is_active(bool p_active) {
_is_active = p_active; _is_active = p_active;
} }
bool PropDataPortal::get_is_two_way() const { bool PropDataPortal2D::get_is_two_way() const {
return _is_two_way; return _is_two_way;
} }
void PropDataPortal::set_is_two_way(bool p_two_way) { void PropDataPortal2D::set_is_two_way(bool p_two_way) {
_is_two_way = p_two_way; _is_two_way = p_two_way;
} }
bool PropDataPortal::get_use_default_margin() const { bool PropDataPortal2D::get_use_default_margin() const {
return _use_default_margin; return _use_default_margin;
} }
void PropDataPortal::set_use_default_margin(bool p_use) { void PropDataPortal2D::set_use_default_margin(bool p_use) {
_use_default_margin = p_use; _use_default_margin = p_use;
} }
real_t PropDataPortal::get_portal_margin() const { real_t PropDataPortal2D::get_portal_margin() const {
return _portal_margin; return _portal_margin;
} }
void PropDataPortal::set_portal_margin(real_t p_margin) { void PropDataPortal2D::set_portal_margin(real_t p_margin) {
_portal_margin = p_margin; _portal_margin = p_margin;
} }
PoolVector<Vector2> PropDataPortal::get_points() const { PoolVector<Vector2> PropDataPortal2D::get_points() const {
return _points; return _points;
} }
void PropDataPortal::set_points(const PoolVector<Vector2> &p_points) { void PropDataPortal2D::set_points(const PoolVector<Vector2> &p_points) {
_points = p_points; _points = p_points;
} }
bool PropDataPortal::_processor_handles(Node *node) { bool PropDataPortal2D::_processor_handles(Node *node) {
Portal *p = Object::cast_to<Portal>(node); Portal *p = Object::cast_to<Portal>(node);
return p; return p;
} }
void PropDataPortal::_processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform) { void PropDataPortal2D::_processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform) {
Portal *p = Object::cast_to<Portal>(node); Portal *p = Object::cast_to<Portal>(node);
ERR_FAIL_COND(!p); ERR_FAIL_COND(!p);
Ref<PropDataPortal> l; Ref<PropDataPortal2D> l;
l.instance(); l.instance();
l->set_is_active(p->get_portal_active()); l->set_is_active(p->get_portal_active());
l->set_is_two_way(p->is_two_way()); l->set_is_two_way(p->is_two_way());
@ -84,7 +84,7 @@ void PropDataPortal::_processor_process(Ref<PropData> prop_data, Node *node, con
prop_data->add_prop(l); prop_data->add_prop(l);
} }
Node *PropDataPortal::_processor_get_node_for(const Transform &transform) { Node *PropDataPortal2D::_processor_get_node_for(const Transform &transform) {
Portal *p = memnew(Portal); Portal *p = memnew(Portal);
p->set_portal_active(get_is_active()); p->set_portal_active(get_is_active());
@ -98,33 +98,33 @@ Node *PropDataPortal::_processor_get_node_for(const Transform &transform) {
return p; return p;
} }
PropDataPortal::PropDataPortal() { PropDataPortal2D::PropDataPortal2D() {
_is_active = true; _is_active = true;
_is_two_way = true; _is_two_way = true;
_use_default_margin = true; _use_default_margin = true;
_portal_margin = 1; _portal_margin = 1;
} }
PropDataPortal::~PropDataPortal() { PropDataPortal2D::~PropDataPortal2D() {
} }
void PropDataPortal::_bind_methods() { void PropDataPortal2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_is_active"), &PropDataPortal::get_is_active); ClassDB::bind_method(D_METHOD("get_is_active"), &PropDataPortal2D::get_is_active);
ClassDB::bind_method(D_METHOD("set_is_active", "value"), &PropDataPortal::set_is_active); ClassDB::bind_method(D_METHOD("set_is_active", "value"), &PropDataPortal2D::set_is_active);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "is_active"), "set_is_active", "get_is_active"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "is_active"), "set_is_active", "get_is_active");
ClassDB::bind_method(D_METHOD("get_is_two_way"), &PropDataPortal::get_is_two_way); ClassDB::bind_method(D_METHOD("get_is_two_way"), &PropDataPortal2D::get_is_two_way);
ClassDB::bind_method(D_METHOD("set_is_two_way", "value"), &PropDataPortal::set_is_two_way); ClassDB::bind_method(D_METHOD("set_is_two_way", "value"), &PropDataPortal2D::set_is_two_way);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "is_two_way"), "set_is_two_way", "get_is_two_way"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "is_two_way"), "set_is_two_way", "get_is_two_way");
ClassDB::bind_method(D_METHOD("get_use_default_margin"), &PropDataPortal::get_use_default_margin); ClassDB::bind_method(D_METHOD("get_use_default_margin"), &PropDataPortal2D::get_use_default_margin);
ClassDB::bind_method(D_METHOD("set_use_default_margin", "value"), &PropDataPortal::set_use_default_margin); ClassDB::bind_method(D_METHOD("set_use_default_margin", "value"), &PropDataPortal2D::set_use_default_margin);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_default_margin"), "set_use_default_margin", "get_use_default_margin"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_default_margin"), "set_use_default_margin", "get_use_default_margin");
ClassDB::bind_method(D_METHOD("get_portal_margin"), &PropDataPortal::get_portal_margin); ClassDB::bind_method(D_METHOD("get_portal_margin"), &PropDataPortal2D::get_portal_margin);
ClassDB::bind_method(D_METHOD("set_portal_margin", "value"), &PropDataPortal::set_portal_margin); ClassDB::bind_method(D_METHOD("set_portal_margin", "value"), &PropDataPortal2D::set_portal_margin);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "portal_margin"), "set_portal_margin", "get_portal_margin"); ADD_PROPERTY(PropertyInfo(Variant::REAL, "portal_margin"), "set_portal_margin", "get_portal_margin");
ClassDB::bind_method(D_METHOD("get_points"), &PropDataPortal::get_points); ClassDB::bind_method(D_METHOD("get_points"), &PropDataPortal2D::get_points);
ClassDB::bind_method(D_METHOD("set_points", "value"), &PropDataPortal::set_points); ClassDB::bind_method(D_METHOD("set_points", "value"), &PropDataPortal2D::set_points);
ADD_PROPERTY(PropertyInfo(Variant::POOL_VECTOR2_ARRAY, "points"), "set_points", "get_points"); ADD_PROPERTY(PropertyInfo(Variant::POOL_VECTOR2_ARRAY, "points"), "set_points", "get_points");
} }

10
props/prop_data_portal_2d.h
View File

@ -27,8 +27,8 @@ SOFTWARE.
#include "prop_data_entry_2d.h" #include "prop_data_entry_2d.h"
class PropDataPortal : public PropDataEntry { class PropDataPortal2D : public PropDataEntry2D {
GDCLASS(PropDataPortal, PropDataEntry); GDCLASS(PropDataPortal2D, PropDataEntry2D);
public: public:
bool get_is_active() const; bool get_is_active() const;
@ -47,11 +47,11 @@ public:
void set_points(const PoolVector<Vector2> &p_points); void set_points(const PoolVector<Vector2> &p_points);
bool _processor_handles(Node *node); bool _processor_handles(Node *node);
void _processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform); void _processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform);
Node *_processor_get_node_for(const Transform &transform); Node *_processor_get_node_for(const Transform &transform);
PropDataPortal(); PropDataPortal2D();
~PropDataPortal(); ~PropDataPortal2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();

50
props/prop_data_prop_2d.cpp
View File

@ -25,55 +25,55 @@ SOFTWARE.
#include "../prop_instance_2d.h" #include "../prop_instance_2d.h"
#include "prop_data_2d.h" #include "prop_data_2d.h"
Ref<PropData> PropDataProp::get_prop() const { Ref<PropData2D> PropDataProp2D::get_prop() const {
return _prop; return _prop;
} }
void PropDataProp::set_prop(const Ref<PropData> value) { void PropDataProp2D::set_prop(const Ref<PropData2D> value) {
_prop = value; _prop = value;
} }
bool PropDataProp::get_snap_to_mesh() { bool PropDataProp2D::get_snap_to_mesh() {
return _snap_to_mesh; return _snap_to_mesh;
} }
void PropDataProp::set_snap_to_mesh(bool value) { void PropDataProp2D::set_snap_to_mesh(bool value) {
_snap_to_mesh = value; _snap_to_mesh = value;
} }
Vector3 PropDataProp::get_snap_axis() { Vector3 PropDataProp2D::get_snap_axis() {
return _snap_axis; return _snap_axis;
} }
void PropDataProp::set_snap_axis(Vector3 value) { void PropDataProp2D::set_snap_axis(Vector3 value) {
_snap_axis = value; _snap_axis = value;
} }
#if TEXTURE_PACKER_PRESENT #if TEXTURE_PACKER_PRESENT
void PropDataProp::_add_textures_into(Ref<TexturePacker> texture_packer) { void PropDataProp2D::_add_textures_into(Ref<TexturePacker> texture_packer) {
if (get_prop().is_valid()) { if (get_prop().is_valid()) {
get_prop()->add_textures_into(texture_packer); get_prop()->add_textures_into(texture_packer);
} }
} }
#endif #endif
bool PropDataProp::_processor_handles(Node *node) { bool PropDataProp2D::_processor_handles(Node *node) {
PropInstance *i = Object::cast_to<PropInstance>(node); PropInstance2D *i = Object::cast_to<PropInstance2D>(node);
return i; return i;
} }
void PropDataProp::_processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform) { void PropDataProp2D::_processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform) {
PropInstance *i = Object::cast_to<PropInstance>(node); PropInstance2D *i = Object::cast_to<PropInstance2D>(node);
ERR_FAIL_COND(!i); ERR_FAIL_COND(!i);
Ref<PropDataProp> l; Ref<PropDataProp2D> l;
l.instance(); l.instance();
l->set_prop(i->get_prop_data()); l->set_prop(i->get_prop_data());
l->set_transform(transform * i->get_transform()); l->set_transform(transform * i->get_transform());
prop_data->add_prop(l); prop_data->add_prop(l);
} }
Node *PropDataProp::_processor_get_node_for(const Transform &transform) { Node *PropDataProp2D::_processor_get_node_for(const Transform &transform) {
PropInstance *i = memnew(PropInstance); PropInstance2D *i = memnew(PropInstance2D);
i->set_prop_data(get_prop()); i->set_prop_data(get_prop());
i->set_transform(get_transform()); i->set_transform(get_transform());
@ -81,29 +81,29 @@ Node *PropDataProp::_processor_get_node_for(const Transform &transform) {
return i; return i;
} }
PropDataProp::PropDataProp() { PropDataProp2D::PropDataProp2D() {
_snap_to_mesh = false; _snap_to_mesh = false;
_snap_axis = Vector3(0, 1, 0); _snap_axis = Vector3(0, 1, 0);
} }
PropDataProp::~PropDataProp() { PropDataProp2D::~PropDataProp2D() {
if (_prop.is_valid()) if (_prop.is_valid())
_prop.unref(); _prop.unref();
} }
void PropDataProp::_bind_methods() { void PropDataProp2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_prop"), &PropDataProp::get_prop); ClassDB::bind_method(D_METHOD("get_prop"), &PropDataProp2D::get_prop);
ClassDB::bind_method(D_METHOD("set_prop", "value"), &PropDataProp::set_prop); ClassDB::bind_method(D_METHOD("set_prop", "value"), &PropDataProp2D::set_prop);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "prop", PROPERTY_HINT_RESOURCE_TYPE, "PropData"), "set_prop", "get_prop"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "prop", PROPERTY_HINT_RESOURCE_TYPE, "PropData2D"), "set_prop", "get_prop");
ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropDataProp::get_snap_to_mesh); ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropDataProp2D::get_snap_to_mesh);
ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropDataProp::set_snap_to_mesh); ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropDataProp2D::set_snap_to_mesh);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_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("get_snap_axis"), &PropDataProp2D::get_snap_axis);
ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropDataProp::set_snap_axis); ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropDataProp2D::set_snap_axis);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis"); ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis");
#if TEXTURE_PACKER_PRESENT #if TEXTURE_PACKER_PRESENT
ClassDB::bind_method(D_METHOD("_add_textures_into", "texture_packer"), &PropDataProp::_add_textures_into); ClassDB::bind_method(D_METHOD("_add_textures_into", "texture_packer"), &PropDataProp2D::_add_textures_into);
#endif #endif
} }

16
props/prop_data_prop_2d.h
View File

@ -32,12 +32,12 @@ SOFTWARE.
#include "../../texture_packer/texture_packer.h" #include "../../texture_packer/texture_packer.h"
#endif #endif
class PropDataProp : public PropDataEntry { class PropDataProp2D : public PropDataEntry2D {
GDCLASS(PropDataProp, PropDataEntry); GDCLASS(PropDataProp2D, PropDataEntry2D);
public: public:
Ref<PropData> get_prop() const; Ref<PropData2D> get_prop() const;
void set_prop(const Ref<PropData> value); void set_prop(const Ref<PropData2D> value);
bool get_snap_to_mesh(); bool get_snap_to_mesh();
void set_snap_to_mesh(bool value); void set_snap_to_mesh(bool value);
@ -50,11 +50,11 @@ public:
#endif #endif
bool _processor_handles(Node *node); bool _processor_handles(Node *node);
void _processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform); void _processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform);
Node *_processor_get_node_for(const Transform &transform); Node *_processor_get_node_for(const Transform &transform);
PropDataProp(); PropDataProp2D();
~PropDataProp(); ~PropDataProp2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();
@ -62,7 +62,7 @@ protected:
private: private:
bool _snap_to_mesh; bool _snap_to_mesh;
Vector3 _snap_axis; Vector3 _snap_axis;
Ref<PropData> _prop; Ref<PropData2D> _prop;
}; };
#endif #endif

44
props/prop_data_scene_2d.cpp
View File

@ -25,47 +25,47 @@ SOFTWARE.
#include "../prop_scene_instance_2d.h" #include "../prop_scene_instance_2d.h"
#include "prop_data_2d.h" #include "prop_data_2d.h"
Ref<PackedScene> PropDataScene::get_scene() { Ref<PackedScene> PropDataScene2D::get_scene() {
return _scene; return _scene;
} }
void PropDataScene::set_scene(const Ref<PackedScene> &value) { void PropDataScene2D::set_scene(const Ref<PackedScene> &value) {
_scene = value; _scene = value;
} }
bool PropDataScene::get_snap_to_mesh() { bool PropDataScene2D::get_snap_to_mesh() {
return _snap_to_mesh; return _snap_to_mesh;
} }
void PropDataScene::set_snap_to_mesh(bool value) { void PropDataScene2D::set_snap_to_mesh(bool value) {
_snap_to_mesh = value; _snap_to_mesh = value;
} }
Vector3 PropDataScene::get_snap_axis() { Vector3 PropDataScene2D::get_snap_axis() {
return _snap_axis; return _snap_axis;
} }
void PropDataScene::set_snap_axis(Vector3 value) { void PropDataScene2D::set_snap_axis(Vector3 value) {
_snap_axis = value; _snap_axis = value;
} }
bool PropDataScene::_processor_handles(Node *node) { bool PropDataScene2D::_processor_handles(Node *node) {
PropSceneInstance *i = Object::cast_to<PropSceneInstance>(node); PropSceneInstance2D *i = Object::cast_to<PropSceneInstance2D>(node);
return i; return i;
} }
void PropDataScene::_processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform) { void PropDataScene2D::_processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform) {
PropSceneInstance *i = Object::cast_to<PropSceneInstance>(node); PropSceneInstance2D *i = Object::cast_to<PropSceneInstance2D>(node);
ERR_FAIL_COND(!i); ERR_FAIL_COND(!i);
Ref<PropDataScene> l; Ref<PropDataScene2D> l;
l.instance(); l.instance();
l->set_scene(i->get_scene()); l->set_scene(i->get_scene());
l->set_transform(transform * i->get_transform()); l->set_transform(transform * i->get_transform());
prop_data->add_prop(l); prop_data->add_prop(l);
} }
Node *PropDataScene::_processor_get_node_for(const Transform &transform) { Node *PropDataScene2D::_processor_get_node_for(const Transform &transform) {
PropSceneInstance *i = memnew(PropSceneInstance); PropSceneInstance2D *i = memnew(PropSceneInstance2D);
i->set_scene(get_scene()); i->set_scene(get_scene());
i->set_transform(get_transform()); i->set_transform(get_transform());
@ -73,25 +73,25 @@ Node *PropDataScene::_processor_get_node_for(const Transform &transform) {
return i; return i;
} }
PropDataScene::PropDataScene() { PropDataScene2D::PropDataScene2D() {
_snap_to_mesh = true; _snap_to_mesh = true;
_snap_axis = Vector3(0, 1, 0); _snap_axis = Vector3(0, 1, 0);
} }
PropDataScene::~PropDataScene() { PropDataScene2D::~PropDataScene2D() {
if (_scene.is_valid()) if (_scene.is_valid())
_scene.unref(); _scene.unref();
} }
void PropDataScene::_bind_methods() { void PropDataScene2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_scene"), &PropDataScene::get_scene); ClassDB::bind_method(D_METHOD("get_scene"), &PropDataScene2D::get_scene);
ClassDB::bind_method(D_METHOD("set_scene", "value"), &PropDataScene::set_scene); ClassDB::bind_method(D_METHOD("set_scene", "value"), &PropDataScene2D::set_scene);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "scene", PROPERTY_HINT_RESOURCE_TYPE, "PackedScene"), "set_scene", "get_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("get_snap_to_mesh"), &PropDataScene2D::get_snap_to_mesh);
ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropDataScene::set_snap_to_mesh); ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropDataScene2D::set_snap_to_mesh);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_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("get_snap_axis"), &PropDataScene2D::get_snap_axis);
ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropDataScene::set_snap_axis); ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropDataScene2D::set_snap_axis);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis"); ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis");
} }

10
props/prop_data_scene_2d.h
View File

@ -28,8 +28,8 @@ SOFTWARE.
#include "scene/resources/packed_scene.h" #include "scene/resources/packed_scene.h"
class PropDataScene : public PropDataEntry { class PropDataScene2D : public PropDataEntry2D {
GDCLASS(PropDataScene, PropDataEntry); GDCLASS(PropDataScene2D, PropDataEntry2D);
public: public:
Ref<PackedScene> get_scene(); Ref<PackedScene> get_scene();
@ -42,11 +42,11 @@ public:
void set_snap_axis(Vector3 value); void set_snap_axis(Vector3 value);
bool _processor_handles(Node *node); bool _processor_handles(Node *node);
void _processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform); void _processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform);
Node *_processor_get_node_for(const Transform &transform); Node *_processor_get_node_for(const Transform &transform);
PropDataScene(); PropDataScene2D();
~PropDataScene(); ~PropDataScene2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();

54
props/prop_data_tiled_wall_2d.cpp
View File

@ -27,46 +27,46 @@ SOFTWARE.
#include "prop_data_2d.h" #include "prop_data_2d.h"
int PropDataTiledWall::get_width() const { int PropDataTiledWall2D::get_width() const {
return _width; return _width;
} }
void PropDataTiledWall::set_width(const int value) { void PropDataTiledWall2D::set_width(const int value) {
_width = value; _width = value;
} }
int PropDataTiledWall::get_heigth() const { int PropDataTiledWall2D::get_heigth() const {
return _height; return _height;
} }
void PropDataTiledWall::set_heigth(const int value) { void PropDataTiledWall2D::set_heigth(const int value) {
_height = value; _height = value;
} }
Ref<TiledWallData> PropDataTiledWall::get_data() { Ref<TiledWallData2D> PropDataTiledWall2D::get_data() {
return _data; return _data;
} }
void PropDataTiledWall::set_data(const Ref<TiledWallData> &data) { void PropDataTiledWall2D::set_data(const Ref<TiledWallData2D> &data) {
_data = data; _data = data;
} }
bool PropDataTiledWall::get_collision() const { bool PropDataTiledWall2D::get_collision() const {
return _collision; return _collision;
} }
void PropDataTiledWall::set_collision(const int value) { void PropDataTiledWall2D::set_collision(const int value) {
_collision = value; _collision = value;
} }
bool PropDataTiledWall::_processor_handles(Node *node) { bool PropDataTiledWall2D::_processor_handles(Node *node) {
TiledWall *t = Object::cast_to<TiledWall>(node); TiledWall2D *t = Object::cast_to<TiledWall2D>(node);
return t; return t;
} }
void PropDataTiledWall::_processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform) { void PropDataTiledWall2D::_processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform) {
TiledWall *t = Object::cast_to<TiledWall>(node); TiledWall2D *t = Object::cast_to<TiledWall2D>(node);
ERR_FAIL_COND(!t); ERR_FAIL_COND(!t);
Ref<PropDataTiledWall> tw; Ref<PropDataTiledWall2D> tw;
tw.instance(); tw.instance();
tw->set_width(t->get_width()); tw->set_width(t->get_width());
@ -77,8 +77,8 @@ void PropDataTiledWall::_processor_process(Ref<PropData> prop_data, Node *node,
prop_data->add_prop(tw); prop_data->add_prop(tw);
} }
Node *PropDataTiledWall::_processor_get_node_for(const Transform &transform) { Node *PropDataTiledWall2D::_processor_get_node_for(const Transform &transform) {
TiledWall *t = memnew(TiledWall); TiledWall2D *t = memnew(TiledWall2D);
t->set_width(get_width()); t->set_width(get_width());
t->set_heigth(get_heigth()); t->set_heigth(get_heigth());
@ -89,29 +89,29 @@ Node *PropDataTiledWall::_processor_get_node_for(const Transform &transform) {
return t; return t;
} }
PropDataTiledWall::PropDataTiledWall() { PropDataTiledWall2D::PropDataTiledWall2D() {
_width = 1; _width = 1;
_height = 1; _height = 1;
_collision = true; _collision = true;
} }
PropDataTiledWall::~PropDataTiledWall() { PropDataTiledWall2D::~PropDataTiledWall2D() {
_data.unref(); _data.unref();
} }
void PropDataTiledWall::_bind_methods() { void PropDataTiledWall2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_width"), &PropDataTiledWall::get_width); ClassDB::bind_method(D_METHOD("get_width"), &PropDataTiledWall2D::get_width);
ClassDB::bind_method(D_METHOD("set_width", "value"), &PropDataTiledWall::set_width); ClassDB::bind_method(D_METHOD("set_width", "value"), &PropDataTiledWall2D::set_width);
ADD_PROPERTY(PropertyInfo(Variant::INT, "width"), "set_width", "get_width"); ADD_PROPERTY(PropertyInfo(Variant::INT, "width"), "set_width", "get_width");
ClassDB::bind_method(D_METHOD("get_heigth"), &PropDataTiledWall::get_heigth); ClassDB::bind_method(D_METHOD("get_heigth"), &PropDataTiledWall2D::get_heigth);
ClassDB::bind_method(D_METHOD("set_heigth", "value"), &PropDataTiledWall::set_heigth); ClassDB::bind_method(D_METHOD("set_heigth", "value"), &PropDataTiledWall2D::set_heigth);
ADD_PROPERTY(PropertyInfo(Variant::INT, "heigth"), "set_heigth", "get_heigth"); ADD_PROPERTY(PropertyInfo(Variant::INT, "heigth"), "set_heigth", "get_heigth");
ClassDB::bind_method(D_METHOD("get_data"), &PropDataTiledWall::get_data); ClassDB::bind_method(D_METHOD("get_data"), &PropDataTiledWall2D::get_data);
ClassDB::bind_method(D_METHOD("set_data", "value"), &PropDataTiledWall::set_data); ClassDB::bind_method(D_METHOD("set_data", "value"), &PropDataTiledWall2D::set_data);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "TiledWallData"), "set_data", "get_data"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "TiledWall2DData"), "set_data", "get_data");
ClassDB::bind_method(D_METHOD("get_collision"), &PropDataTiledWall::get_collision); ClassDB::bind_method(D_METHOD("get_collision"), &PropDataTiledWall2D::get_collision);
ClassDB::bind_method(D_METHOD("set_collision", "value"), &PropDataTiledWall::set_collision); ClassDB::bind_method(D_METHOD("set_collision", "value"), &PropDataTiledWall2D::set_collision);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collision"), "set_collision", "get_collision"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collision"), "set_collision", "get_collision");
} }

18
props/prop_data_tiled_wall_2d.h
View File

@ -26,10 +26,10 @@ SOFTWARE.
#include "core/math/vector3.h" #include "core/math/vector3.h"
#include "prop_data_entry_2d.h" #include "prop_data_entry_2d.h"
class TiledWallData; class TiledWallData2D;
class PropDataTiledWall : public PropDataEntry { class PropDataTiledWall2D : public PropDataEntry2D {
GDCLASS(PropDataTiledWall, PropDataEntry); GDCLASS(PropDataTiledWall2D, PropDataEntry2D);
public: public:
int get_width() const; int get_width() const;
@ -38,18 +38,18 @@ public:
int get_heigth() const; int get_heigth() const;
void set_heigth(const int value); void set_heigth(const int value);
Ref<TiledWallData> get_data(); Ref<TiledWallData2D> get_data();
void set_data(const Ref<TiledWallData> &data); void set_data(const Ref<TiledWallData2D> &data);
bool get_collision() const; bool get_collision() const;
void set_collision(const int value); void set_collision(const int value);
bool _processor_handles(Node *node); bool _processor_handles(Node *node);
void _processor_process(Ref<PropData> prop_data, Node *node, const Transform &transform); void _processor_process(Ref<PropData2D> prop_data, Node *node, const Transform &transform);
Node *_processor_get_node_for(const Transform &transform); Node *_processor_get_node_for(const Transform &transform);
PropDataTiledWall(); PropDataTiledWall2D();
~PropDataTiledWall(); ~PropDataTiledWall2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();
@ -59,7 +59,7 @@ private:
int _height; int _height;
bool _collision; bool _collision;
Ref<TiledWallData> _data; Ref<TiledWallData2D> _data;
}; };
#endif #endif

84
register_types.cpp
View File

@ -74,77 +74,77 @@ SOFTWARE.
#include "material_cache/prop_material_cache_pcm_2d.h" #include "material_cache/prop_material_cache_pcm_2d.h"
#endif #endif
static PropUtils *prop_utils = NULL; static PropUtils2D *prop_utils = NULL;
static PropCache *prop_texture_cache = NULL; static PropCache2D *prop_texture_cache = NULL;
void register_props_2d_types() { void register_props_2d_types() {
ClassDB::register_class<TiledWall>(); ClassDB::register_class<TiledWall2D>();
ClassDB::register_class<TiledWallData>(); ClassDB::register_class<TiledWallData2D>();
ClassDB::register_class<PropLight>(); ClassDB::register_class<PropLight2D>();
ClassDB::register_class<PropData>(); ClassDB::register_class<PropData2D>();
ClassDB::register_class<PropDataEntry>(); ClassDB::register_class<PropDataEntry2D>();
ClassDB::register_class<PropDataScene>(); ClassDB::register_class<PropDataScene2D>();
ClassDB::register_class<PropDataLight>(); ClassDB::register_class<PropDataLight2D>();
ClassDB::register_class<PropDataProp>(); ClassDB::register_class<PropDataProp2D>();
ClassDB::register_class<PropDataTiledWall>(); ClassDB::register_class<PropDataTiledWall2D>();
#if VERSION_MINOR >= 4 #if VERSION_MINOR >= 4
ClassDB::register_class<PropDataPortal>(); ClassDB::register_class<PropDataPortal2D>();
#endif #endif
ClassDB::register_class<GroundClutter>(); ClassDB::register_class<GroundClutter2D>();
ClassDB::register_class<GroundClutterFoliage>(); ClassDB::register_class<GroundClutterFoliage2D>();
ClassDB::register_class<PropMesher>(); ClassDB::register_class<PropMesher2D>();
ClassDB::register_class<PropMesherJobStep>(); ClassDB::register_class<PropMesherJobStep2D>();
ClassDB::register_class<PropInstance>(); ClassDB::register_class<PropInstance2D>();
ClassDB::register_class<PropInstanceMerger>(); ClassDB::register_class<PropInstanceMerger2D>();
ClassDB::register_class<PropESSEntity>(); ClassDB::register_class<PropESSEntity2D>();
ClassDB::register_class<PropInstanceJob>(); ClassDB::register_class<PropInstanceJob2D>();
ClassDB::register_class<PropInstancePropJob>(); ClassDB::register_class<PropInstancePropJob2D>();
ClassDB::register_class<PropTextureJob>(); ClassDB::register_class<PropTextureJob2D>();
ClassDB::register_class<PropSceneInstance>(); ClassDB::register_class<PropSceneInstance2D>();
ClassDB::register_class<PropMaterialCache>(); ClassDB::register_class<PropMaterialCache2D>();
#ifdef TEXTURE_PACKER_PRESENT #ifdef TEXTURE_PACKER_PRESENT
ClassDB::register_class<PropMaterialCachePCM>(); ClassDB::register_class<PropMaterialCachePCM2D>();
#endif #endif
prop_utils = memnew(PropUtils); prop_utils = memnew(PropUtils2D);
ClassDB::register_class<PropUtils>(); ClassDB::register_class<PropUtils2D>();
Engine::get_singleton()->add_singleton(Engine::Singleton("PropUtils", PropUtils::get_singleton())); Engine::get_singleton()->add_singleton(Engine::Singleton("PropUtils2D", PropUtils2D::get_singleton()));
prop_texture_cache = memnew(PropCache); prop_texture_cache = memnew(PropCache2D);
ClassDB::register_class<PropCache>(); ClassDB::register_class<PropCache2D>();
Engine::get_singleton()->add_singleton(Engine::Singleton("PropCache", PropCache::get_singleton())); Engine::get_singleton()->add_singleton(Engine::Singleton("PropCache2D", PropCache2D::get_singleton()));
Ref<PropDataLight> light_processor = Ref<PropDataLight>(memnew(PropDataLight)); Ref<PropDataLight2D> light_processor = Ref<PropDataLight2D>(memnew(PropDataLight2D));
PropUtils::add_processor(light_processor); PropUtils2D::add_processor(light_processor);
Ref<PropDataProp> prop_processor = Ref<PropDataProp>(memnew(PropDataProp)); Ref<PropDataProp2D> prop_processor = Ref<PropDataProp2D>(memnew(PropDataProp2D));
PropUtils::add_processor(prop_processor); PropUtils2D::add_processor(prop_processor);
Ref<PropDataScene> scene_processor = Ref<PropDataScene>(memnew(PropDataScene)); Ref<PropDataScene2D> scene_processor = Ref<PropDataScene2D>(memnew(PropDataScene2D));
PropUtils::add_processor(scene_processor); PropUtils2D::add_processor(scene_processor);
#if VERSION_MINOR >= 4 #if VERSION_MINOR >= 4
Ref<PropDataPortal> portal_processor = Ref<PropDataPortal>(memnew(PropDataPortal)); Ref<PropDataPortal2D> portal_processor = Ref<PropDataPortal2D>(memnew(PropDataPortal2D));
PropUtils::add_processor(portal_processor); PropUtils2D::add_processor(portal_processor);
#endif #endif
Ref<PropDataTiledWall> tiled_wall_processor = Ref<PropDataTiledWall>(memnew(PropDataTiledWall)); Ref<PropDataTiledWall2D> tiled_wall_processor = Ref<PropDataTiledWall2D>(memnew(PropDataTiledWall2D));
PropUtils::add_processor(tiled_wall_processor); PropUtils2D::add_processor(tiled_wall_processor);
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<PropEditorPlugin>(); EditorPlugins::add_by_type<PropEditorPlugin2D>();
#endif #endif
} }

186
singleton/prop_cache_2d.cpp
View File

@ -66,94 +66,94 @@ SOFTWARE.
#endif #endif
PropCache *PropCache::_instance; PropCache2D *PropCache2D::_instance;
PropCache *PropCache::get_singleton() { PropCache2D *PropCache2D::get_singleton() {
return _instance; return _instance;
} }
StringName PropCache::get_default_prop_material_cache_class() { StringName PropCache2D::get_default_prop_material_cache_class() {
return _default_prop_material_cache_class; return _default_prop_material_cache_class;
} }
void PropCache::set_default_prop_material_cache_class(const StringName &cls_name) { void PropCache2D::set_default_prop_material_cache_class(const StringName &cls_name) {
_default_prop_material_cache_class = cls_name; _default_prop_material_cache_class = cls_name;
} }
#ifdef TEXTURE_PACKER_PRESENT #ifdef TEXTURE_PACKER_PRESENT
int PropCache::get_texture_flags() const { int PropCache2D::get_texture_flags() const {
return _texture_flags; return _texture_flags;
} }
void PropCache::set_texture_flags(const int flags) { void PropCache2D::set_texture_flags(const int flags) {
_texture_flags = flags; _texture_flags = flags;
} }
int PropCache::get_max_atlas_size() const { int PropCache2D::get_max_atlas_size() const {
return _max_atlas_size; return _max_atlas_size;
} }
void PropCache::set_max_atlas_size(const int size) { void PropCache2D::set_max_atlas_size(const int size) {
_max_atlas_size = size; _max_atlas_size = size;
} }
bool PropCache::get_keep_original_atlases() const { bool PropCache2D::get_keep_original_atlases() const {
return _keep_original_atlases; return _keep_original_atlases;
} }
void PropCache::set_keep_original_atlases(const bool value) { void PropCache2D::set_keep_original_atlases(const bool value) {
_keep_original_atlases = value; _keep_original_atlases = value;
} }
Color PropCache::get_background_color() const { Color PropCache2D::get_background_color() const {
return _background_color; return _background_color;
} }
void PropCache::set_background_color(const Color &color) { void PropCache2D::set_background_color(const Color &color) {
_background_color = color; _background_color = color;
} }
int PropCache::get_margin() const { int PropCache2D::get_margin() const {
return _margin; return _margin;
} }
void PropCache::set_margin(const int margin) { void PropCache2D::set_margin(const int margin) {
_margin = margin; _margin = margin;
} }
#endif #endif
PoolStringArray PropCache::material_paths_get() const { PoolStringArray PropCache2D::material_paths_get() const {
return _material_paths; return _material_paths;
} }
void PropCache::material_paths_set(const PoolStringArray &value) { void PropCache2D::material_paths_set(const PoolStringArray &value) {
_material_paths = value; _material_paths = value;
} }
void PropCache::material_add(const Ref<Material> &value) { void PropCache2D::material_add(const Ref<Material> &value) {
ERR_FAIL_COND(!value.is_valid()); ERR_FAIL_COND(!value.is_valid());
_materials.push_back(value); _materials.push_back(value);
} }
Ref<Material> PropCache::material_get(const int index) { Ref<Material> PropCache2D::material_get(const int index) {
ERR_FAIL_INDEX_V(index, _materials.size(), Ref<Material>()); ERR_FAIL_INDEX_V(index, _materials.size(), Ref<Material>());
return _materials[index]; return _materials[index];
} }
void PropCache::material_set(const int index, const Ref<Material> &value) { void PropCache2D::material_set(const int index, const Ref<Material> &value) {
ERR_FAIL_INDEX(index, _materials.size()); ERR_FAIL_INDEX(index, _materials.size());
_materials.set(index, value); _materials.set(index, value);
} }
void PropCache::material_remove(const int index) { void PropCache2D::material_remove(const int index) {
_materials.remove(index); _materials.remove(index);
} }
int PropCache::material_get_num() const { int PropCache2D::material_get_num() const {
return _materials.size(); return _materials.size();
} }
void PropCache::materials_clear() { void PropCache2D::materials_clear() {
_materials.clear(); _materials.clear();
} }
void PropCache::materials_load() { void PropCache2D::materials_load() {
_materials.clear(); _materials.clear();
for (int i = 0; i < _material_paths.size(); ++i) { for (int i = 0; i < _material_paths.size(); ++i) {
@ -169,17 +169,17 @@ void PropCache::materials_load() {
} }
} }
void PropCache::ensure_materials_loaded() { void PropCache2D::ensure_materials_loaded() {
if (_materials.size() != _material_paths.size()) { if (_materials.size() != _material_paths.size()) {
materials_load(); materials_load();
} }
} }
Vector<Variant> PropCache::materials_get() { Vector<Variant> PropCache2D::materials_get() {
VARIANT_ARRAY_GET(_materials); VARIANT_ARRAY_GET(_materials);
} }
void PropCache::materials_set(const Vector<Variant> &materials) { void PropCache2D::materials_set(const Vector<Variant> &materials) {
_materials.clear(); _materials.clear();
for (int i = 0; i < materials.size(); i++) { for (int i = 0; i < materials.size(); i++) {
@ -189,16 +189,16 @@ void PropCache::materials_set(const Vector<Variant> &materials) {
} }
} }
Ref<PropMaterialCache> PropCache::material_cache_get(const Ref<PropData> &prop) { Ref<PropMaterialCache2D> PropCache2D::material_cache_get(const Ref<PropData2D> &prop) {
ERR_FAIL_COND_V(!prop.is_valid(), Ref<PropMaterialCache>()); ERR_FAIL_COND_V(!prop.is_valid(), Ref<PropMaterialCache2D>());
//get pointer's value as uint64 //get pointer's value as uint64
uint64_t k = make_uint64_t<const PropData *>(*prop); uint64_t k = make_uint64_t<const PropData2D *>(*prop);
_material_cache_mutex.lock(); _material_cache_mutex.lock();
if (_material_cache.has(k)) { if (_material_cache.has(k)) {
Ref<PropMaterialCache> m = _material_cache[k]; Ref<PropMaterialCache2D> m = _material_cache[k];
m->inc_ref_count(); m->inc_ref_count();
@ -207,13 +207,13 @@ Ref<PropMaterialCache> PropCache::material_cache_get(const Ref<PropData> &prop)
return m; return m;
} }
PropMaterialCache *p = Object::cast_to<PropMaterialCache>(ClassDB::instance(_default_prop_material_cache_class)); PropMaterialCache2D *p = Object::cast_to<PropMaterialCache2D>(ClassDB::instance(_default_prop_material_cache_class));
if (!p) { if (!p) {
ERR_PRINT("Can't instance the given PropMaterialCache! class_name: " + String(_default_prop_material_cache_class)); ERR_PRINT("Can't instance the given PropMaterialCache2D! class_name: " + String(_default_prop_material_cache_class));
} }
Ref<PropMaterialCache> m(p); Ref<PropMaterialCache2D> m(p);
_material_cache[k] = m; _material_cache[k] = m;
@ -221,21 +221,21 @@ Ref<PropMaterialCache> PropCache::material_cache_get(const Ref<PropData> &prop)
return m; return m;
} }
void PropCache::material_cache_unref(const Ref<PropData> &prop) { void PropCache2D::material_cache_unref(const Ref<PropData2D> &prop) {
//get pointer's value as uint64 //get pointer's value as uint64
uint64_t k = make_uint64_t<const PropData *>(*prop); uint64_t k = make_uint64_t<const PropData2D *>(*prop);
_material_cache_mutex.lock(); _material_cache_mutex.lock();
if (!_material_cache.has(k)) { if (!_material_cache.has(k)) {
_material_cache_mutex.unlock(); _material_cache_mutex.unlock();
ERR_PRINT("PropCache::material_cache_unref: can't find cache!"); ERR_PRINT("PropCache2D::material_cache_unref: can't find cache!");
return; return;
} }
Ref<PropMaterialCache> m = _material_cache[k]; Ref<PropMaterialCache2D> m = _material_cache[k];
m->dec_ref_count(); m->dec_ref_count();
if (m->get_ref_count() <= 0) { if (m->get_ref_count() <= 0) {
@ -245,16 +245,16 @@ void PropCache::material_cache_unref(const Ref<PropData> &prop) {
_material_cache_mutex.unlock(); _material_cache_mutex.unlock();
} }
Ref<PropMaterialCache> PropCache::tiled_wall_material_cache_get(const Ref<TiledWallData> &twd) { Ref<PropMaterialCache2D> PropCache2D::tiled_wall_material_cache_get(const Ref<TiledWallData2D> &twd) {
ERR_FAIL_COND_V(!twd.is_valid(), Ref<PropMaterialCache>()); ERR_FAIL_COND_V(!twd.is_valid(), Ref<PropMaterialCache2D>());
//get pointer's value as uint64 //get pointer's value as uint64
uint64_t k = make_uint64_t<const TiledWallData *>(*twd); uint64_t k = make_uint64_t<const TiledWallData2D *>(*twd);
_tiled_wall_material_cache_mutex.lock(); _tiled_wall_material_cache_mutex.lock();
if (_tiled_wall_material_cache.has(k)) { if (_tiled_wall_material_cache.has(k)) {
Ref<PropMaterialCache> m = _tiled_wall_material_cache[k]; Ref<PropMaterialCache2D> m = _tiled_wall_material_cache[k];
m->inc_ref_count(); m->inc_ref_count();
@ -263,13 +263,13 @@ Ref<PropMaterialCache> PropCache::tiled_wall_material_cache_get(const Ref<TiledW
return m; return m;
} }
PropMaterialCache *p = Object::cast_to<PropMaterialCache>(ClassDB::instance(_default_prop_material_cache_class)); PropMaterialCache2D *p = Object::cast_to<PropMaterialCache2D>(ClassDB::instance(_default_prop_material_cache_class));
if (!p) { if (!p) {
ERR_PRINT("Can't instance the given PropMaterialCache! class_name: " + String(_default_prop_material_cache_class)); ERR_PRINT("Can't instance the given PropMaterialCache2D! class_name: " + String(_default_prop_material_cache_class));
} }
Ref<PropMaterialCache> m(p); Ref<PropMaterialCache2D> m(p);
_tiled_wall_material_cache[k] = m; _tiled_wall_material_cache[k] = m;
@ -277,21 +277,21 @@ Ref<PropMaterialCache> PropCache::tiled_wall_material_cache_get(const Ref<TiledW
return m; return m;
} }
void PropCache::tiled_wall_material_cache_unref(const Ref<TiledWallData> &twd) { void PropCache2D::tiled_wall_material_cache_unref(const Ref<TiledWallData2D> &twd) {
//get pointer's value as uint64 //get pointer's value as uint64
uint64_t k = make_uint64_t<const TiledWallData *>(*twd); uint64_t k = make_uint64_t<const TiledWallData2D *>(*twd);
_tiled_wall_material_cache_mutex.lock(); _tiled_wall_material_cache_mutex.lock();
if (!_tiled_wall_material_cache.has(k)) { if (!_tiled_wall_material_cache.has(k)) {
_tiled_wall_material_cache_mutex.unlock(); _tiled_wall_material_cache_mutex.unlock();
ERR_PRINT("PropCache::material_cache_unref: can't find cache!"); ERR_PRINT("PropCache2D::material_cache_unref: can't find cache!");
return; return;
} }
Ref<PropMaterialCache> m = _tiled_wall_material_cache[k]; Ref<PropMaterialCache2D> m = _tiled_wall_material_cache[k];
m->dec_ref_count(); m->dec_ref_count();
if (m->get_ref_count() <= 0) { if (m->get_ref_count() <= 0) {
@ -301,11 +301,11 @@ void PropCache::tiled_wall_material_cache_unref(const Ref<TiledWallData> &twd) {
_tiled_wall_material_cache_mutex.unlock(); _tiled_wall_material_cache_mutex.unlock();
} }
Ref<PropMaterialCache> PropCache::material_cache_custom_key_get(const uint64_t key) { Ref<PropMaterialCache2D> PropCache2D::material_cache_custom_key_get(const uint64_t key) {
_custom_keyed_material_cache_mutex.lock(); _custom_keyed_material_cache_mutex.lock();
if (_custom_keyed_material_cache.has(key)) { if (_custom_keyed_material_cache.has(key)) {
Ref<PropMaterialCache> m = _custom_keyed_material_cache[key]; Ref<PropMaterialCache2D> m = _custom_keyed_material_cache[key];
m->inc_ref_count(); m->inc_ref_count();
@ -314,13 +314,13 @@ Ref<PropMaterialCache> PropCache::material_cache_custom_key_get(const uint64_t k
return m; return m;
} }
PropMaterialCache *p = Object::cast_to<PropMaterialCache>(ClassDB::instance(_default_prop_material_cache_class)); PropMaterialCache2D *p = Object::cast_to<PropMaterialCache2D>(ClassDB::instance(_default_prop_material_cache_class));
if (!p) { if (!p) {
ERR_PRINT("Can't instance the given PropMaterialCache! class_name: " + String(_default_prop_material_cache_class)); ERR_PRINT("Can't instance the given PropMaterialCache2D! class_name: " + String(_default_prop_material_cache_class));
} }
Ref<PropMaterialCache> m(p); Ref<PropMaterialCache2D> m(p);
_custom_keyed_material_cache[key] = m; _custom_keyed_material_cache[key] = m;
@ -328,18 +328,18 @@ Ref<PropMaterialCache> PropCache::material_cache_custom_key_get(const uint64_t k
return m; return m;
} }
void PropCache::material_cache_custom_key_unref(const uint64_t key) { void PropCache2D::material_cache_custom_key_unref(const uint64_t key) {
_custom_keyed_material_cache_mutex.lock(); _custom_keyed_material_cache_mutex.lock();
if (!_material_cache.has(key)) { if (!_material_cache.has(key)) {
_custom_keyed_material_cache_mutex.unlock(); _custom_keyed_material_cache_mutex.unlock();
ERR_PRINT("PropCache::material_cache_custom_key_unref: can't find cache!"); ERR_PRINT("PropCache2D::material_cache_custom_key_unref: can't find cache!");
return; return;
} }
Ref<PropMaterialCache> m = _custom_keyed_material_cache[key]; Ref<PropMaterialCache2D> m = _custom_keyed_material_cache[key];
m->dec_ref_count(); m->dec_ref_count();
if (m->get_ref_count() <= 0) { if (m->get_ref_count() <= 0) {
@ -349,7 +349,7 @@ void PropCache::material_cache_custom_key_unref(const uint64_t key) {
_custom_keyed_material_cache_mutex.unlock(); _custom_keyed_material_cache_mutex.unlock();
} }
Ref<Resource> PropCache::load_resource(const String &path, const String &type_hint) { Ref<Resource> PropCache2D::load_resource(const String &path, const String &type_hint) {
_ResourceLoader *rl = _ResourceLoader::get_singleton(); _ResourceLoader *rl = _ResourceLoader::get_singleton();
#if VERSION_MAJOR < 4 #if VERSION_MAJOR < 4
@ -365,13 +365,13 @@ Ref<Resource> PropCache::load_resource(const String &path, const String &type_hi
#endif #endif
} }
PropCache::PropCache() { PropCache2D::PropCache2D() {
_instance = this; _instance = this;
#if TEXTURE_PACKER_PRESENT #if TEXTURE_PACKER_PRESENT
_default_prop_material_cache_class = GLOBAL_DEF("props/default_prop_material_cache_class", "PropMaterialCachePCM"); _default_prop_material_cache_class = GLOBAL_DEF("props/default_prop_material_cache_class", "PropMaterialCache2DPCM");
#else #else
_default_prop_material_cache_class = GLOBAL_DEF("props/default_prop_material_cache_class", "PropMaterialCache"); _default_prop_material_cache_class = GLOBAL_DEF("props/default_prop_material_cache_class", "PropMaterialCache2D");
#endif #endif
#ifdef TEXTURE_PACKER_PRESENT #ifdef TEXTURE_PACKER_PRESENT
@ -390,62 +390,62 @@ PropCache::PropCache() {
_material_paths = GLOBAL_DEF("props/material_paths", PoolStringArray()); _material_paths = GLOBAL_DEF("props/material_paths", PoolStringArray());
} }
PropCache::~PropCache() { PropCache2D::~PropCache2D() {
_instance = NULL; _instance = NULL;
} }
void PropCache::_bind_methods() { void PropCache2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_default_prop_material_cache_class"), &PropCache::get_default_prop_material_cache_class); ClassDB::bind_method(D_METHOD("get_default_prop_material_cache_class"), &PropCache2D::get_default_prop_material_cache_class);
ClassDB::bind_method(D_METHOD("set_default_prop_material_cache_class", "cls_name"), &PropCache::set_default_prop_material_cache_class); ClassDB::bind_method(D_METHOD("set_default_prop_material_cache_class", "cls_name"), &PropCache2D::set_default_prop_material_cache_class);
ADD_PROPERTY(PropertyInfo(Variant::STRING, "default_prop_material_cache_class"), "set_default_prop_material_cache_class", "get_default_prop_material_cache_class"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "default_prop_material_cache_class"), "set_default_prop_material_cache_class", "get_default_prop_material_cache_class");
#ifdef TEXTURE_PACKER_PRESENT #ifdef TEXTURE_PACKER_PRESENT
ClassDB::bind_method(D_METHOD("get_texture_flags"), &PropCache::get_texture_flags); ClassDB::bind_method(D_METHOD("get_texture_flags"), &PropCache2D::get_texture_flags);
ClassDB::bind_method(D_METHOD("set_texture_flags", "flags"), &PropCache::set_texture_flags); ClassDB::bind_method(D_METHOD("set_texture_flags", "flags"), &PropCache2D::set_texture_flags);
ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_flags", PROPERTY_HINT_FLAGS, "Mipmaps,Repeat,Filter,Anisotropic Linear,Convert to Linear,Mirrored Repeat,Video Surface"), "set_texture_flags", "get_texture_flags"); ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_flags", PROPERTY_HINT_FLAGS, "Mipmaps,Repeat,Filter,Anisotropic Linear,Convert to Linear,Mirrored Repeat,Video Surface"), "set_texture_flags", "get_texture_flags");
ClassDB::bind_method(D_METHOD("get_max_atlas_size"), &PropCache::get_max_atlas_size); ClassDB::bind_method(D_METHOD("get_max_atlas_size"), &PropCache2D::get_max_atlas_size);
ClassDB::bind_method(D_METHOD("set_max_atlas_size", "size"), &PropCache::set_max_atlas_size); ClassDB::bind_method(D_METHOD("set_max_atlas_size", "size"), &PropCache2D::set_max_atlas_size);
ADD_PROPERTY(PropertyInfo(Variant::INT, "max_atlas_size"), "set_max_atlas_size", "get_max_atlas_size"); ADD_PROPERTY(PropertyInfo(Variant::INT, "max_atlas_size"), "set_max_atlas_size", "get_max_atlas_size");
ClassDB::bind_method(D_METHOD("get_keep_original_atlases"), &PropCache::get_keep_original_atlases); ClassDB::bind_method(D_METHOD("get_keep_original_atlases"), &PropCache2D::get_keep_original_atlases);
ClassDB::bind_method(D_METHOD("set_keep_original_atlases", "value"), &PropCache::set_keep_original_atlases); ClassDB::bind_method(D_METHOD("set_keep_original_atlases", "value"), &PropCache2D::set_keep_original_atlases);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "keep_original_atlases"), "set_keep_original_atlases", "get_keep_original_atlases"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "keep_original_atlases"), "set_keep_original_atlases", "get_keep_original_atlases");
ClassDB::bind_method(D_METHOD("get_background_color"), &PropCache::get_background_color); ClassDB::bind_method(D_METHOD("get_background_color"), &PropCache2D::get_background_color);
ClassDB::bind_method(D_METHOD("set_background_color", "color"), &PropCache::set_background_color); ClassDB::bind_method(D_METHOD("set_background_color", "color"), &PropCache2D::set_background_color);
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "background_color"), "set_background_color", "get_background_color"); ADD_PROPERTY(PropertyInfo(Variant::COLOR, "background_color"), "set_background_color", "get_background_color");
ClassDB::bind_method(D_METHOD("get_margin"), &PropCache::get_margin); ClassDB::bind_method(D_METHOD("get_margin"), &PropCache2D::get_margin);
ClassDB::bind_method(D_METHOD("set_margin", "size"), &PropCache::set_margin); ClassDB::bind_method(D_METHOD("set_margin", "size"), &PropCache2D::set_margin);
ADD_PROPERTY(PropertyInfo(Variant::INT, "margin"), "set_margin", "get_margin"); ADD_PROPERTY(PropertyInfo(Variant::INT, "margin"), "set_margin", "get_margin");
#endif #endif
ClassDB::bind_method(D_METHOD("material_paths_get"), &PropCache::material_paths_get); ClassDB::bind_method(D_METHOD("material_paths_get"), &PropCache2D::material_paths_get);
ClassDB::bind_method(D_METHOD("material_paths_set", "value"), &PropCache::material_paths_set); ClassDB::bind_method(D_METHOD("material_paths_set", "value"), &PropCache2D::material_paths_set);
ADD_PROPERTY(PropertyInfo(Variant::POOL_STRING_ARRAY, "material_paths"), "material_paths_set", "material_paths_get"); ADD_PROPERTY(PropertyInfo(Variant::POOL_STRING_ARRAY, "material_paths"), "material_paths_set", "material_paths_get");
ClassDB::bind_method(D_METHOD("material_add", "value"), &PropCache::material_add); ClassDB::bind_method(D_METHOD("material_add", "value"), &PropCache2D::material_add);
ClassDB::bind_method(D_METHOD("material_get", "index"), &PropCache::material_get); ClassDB::bind_method(D_METHOD("material_get", "index"), &PropCache2D::material_get);
ClassDB::bind_method(D_METHOD("material_set", "index", "value"), &PropCache::material_set); ClassDB::bind_method(D_METHOD("material_set", "index", "value"), &PropCache2D::material_set);
ClassDB::bind_method(D_METHOD("material_remove", "index"), &PropCache::material_remove); ClassDB::bind_method(D_METHOD("material_remove", "index"), &PropCache2D::material_remove);
ClassDB::bind_method(D_METHOD("material_get_num"), &PropCache::material_get_num); ClassDB::bind_method(D_METHOD("material_get_num"), &PropCache2D::material_get_num);
ClassDB::bind_method(D_METHOD("materials_clear"), &PropCache::materials_clear); ClassDB::bind_method(D_METHOD("materials_clear"), &PropCache2D::materials_clear);
ClassDB::bind_method(D_METHOD("materials_load"), &PropCache::materials_load); ClassDB::bind_method(D_METHOD("materials_load"), &PropCache2D::materials_load);
ClassDB::bind_method(D_METHOD("ensure_materials_loaded"), &PropCache::ensure_materials_loaded); ClassDB::bind_method(D_METHOD("ensure_materials_loaded"), &PropCache2D::ensure_materials_loaded);
ClassDB::bind_method(D_METHOD("materials_get"), &PropCache::materials_get); ClassDB::bind_method(D_METHOD("materials_get"), &PropCache2D::materials_get);
ClassDB::bind_method(D_METHOD("materials_set"), &PropCache::materials_set); ClassDB::bind_method(D_METHOD("materials_set"), &PropCache2D::materials_set);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "materials_set", "materials_get"); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "materials_set", "materials_get");
ClassDB::bind_method(D_METHOD("material_cache_get", "prop"), &PropCache::material_cache_get); ClassDB::bind_method(D_METHOD("material_cache_get", "prop"), &PropCache2D::material_cache_get);
ClassDB::bind_method(D_METHOD("material_cache_unref", "prop"), &PropCache::material_cache_unref); ClassDB::bind_method(D_METHOD("material_cache_unref", "prop"), &PropCache2D::material_cache_unref);
ClassDB::bind_method(D_METHOD("tiled_wall_material_cache_get", "twd"), &PropCache::tiled_wall_material_cache_get); ClassDB::bind_method(D_METHOD("tiled_wall_material_cache_get", "twd"), &PropCache2D::tiled_wall_material_cache_get);
ClassDB::bind_method(D_METHOD("tiled_wall_material_cache_unref", "twd"), &PropCache::tiled_wall_material_cache_unref); ClassDB::bind_method(D_METHOD("tiled_wall_material_cache_unref", "twd"), &PropCache2D::tiled_wall_material_cache_unref);
ClassDB::bind_method(D_METHOD("material_cache_custom_key_get", "key"), &PropCache::material_cache_custom_key_get); ClassDB::bind_method(D_METHOD("material_cache_custom_key_get", "key"), &PropCache2D::material_cache_custom_key_get);
ClassDB::bind_method(D_METHOD("material_cache_custom_key_unref", "key"), &PropCache::material_cache_custom_key_unref); ClassDB::bind_method(D_METHOD("material_cache_custom_key_unref", "key"), &PropCache2D::material_cache_custom_key_unref);
ClassDB::bind_method(D_METHOD("load_resource", "path", "type_hint"), &PropCache::load_resource, ""); ClassDB::bind_method(D_METHOD("load_resource", "path", "type_hint"), &PropCache2D::load_resource, "");
} }

32
singleton/prop_cache_2d.h
View File

@ -47,14 +47,14 @@ SOFTWARE.
#include "../props/prop_data_2d.h" #include "../props/prop_data_2d.h"
class PropMaterialCache; class PropMaterialCache2D;
class TiledWallData; class TiledWallData2D;
class PropCache : public Object { class PropCache2D : public Object {
GDCLASS(PropCache, Object); GDCLASS(PropCache2D, Object);
public: public:
static PropCache *get_singleton(); static PropCache2D *get_singleton();
StringName get_default_prop_material_cache_class(); StringName get_default_prop_material_cache_class();
void set_default_prop_material_cache_class(const StringName &cls_name); void set_default_prop_material_cache_class(const StringName &cls_name);
@ -91,32 +91,32 @@ public:
Vector<Variant> materials_get(); Vector<Variant> materials_get();
void materials_set(const Vector<Variant> &materials); void materials_set(const Vector<Variant> &materials);
Ref<PropMaterialCache> material_cache_get(const Ref<PropData> &prop); Ref<PropMaterialCache2D> material_cache_get(const Ref<PropData2D> &prop);
void material_cache_unref(const Ref<PropData> &prop); void material_cache_unref(const Ref<PropData2D> &prop);
Ref<PropMaterialCache> tiled_wall_material_cache_get(const Ref<TiledWallData> &twd); Ref<PropMaterialCache2D> tiled_wall_material_cache_get(const Ref<TiledWallData2D> &twd);
void tiled_wall_material_cache_unref(const Ref<TiledWallData> &twd); void tiled_wall_material_cache_unref(const Ref<TiledWallData2D> &twd);
Ref<PropMaterialCache> material_cache_custom_key_get(const uint64_t key); Ref<PropMaterialCache2D> material_cache_custom_key_get(const uint64_t key);
void material_cache_custom_key_unref(const uint64_t key); void material_cache_custom_key_unref(const uint64_t key);
Ref<Resource> load_resource(const String &path, const String &type_hint = ""); Ref<Resource> load_resource(const String &path, const String &type_hint = "");
private: private:
static PropCache *_instance; static PropCache2D *_instance;
public: public:
PropCache(); PropCache2D();
~PropCache(); ~PropCache2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();
StringName _default_prop_material_cache_class; StringName _default_prop_material_cache_class;
Map<uint64_t, Ref<PropMaterialCache>> _material_cache; Map<uint64_t, Ref<PropMaterialCache2D>> _material_cache;
Map<uint64_t, Ref<PropMaterialCache>> _tiled_wall_material_cache; Map<uint64_t, Ref<PropMaterialCache2D>> _tiled_wall_material_cache;
Map<uint64_t, Ref<PropMaterialCache>> _custom_keyed_material_cache; Map<uint64_t, Ref<PropMaterialCache2D>> _custom_keyed_material_cache;
Mutex _material_cache_mutex; Mutex _material_cache_mutex;
Mutex _tiled_wall_material_cache_mutex; Mutex _tiled_wall_material_cache_mutex;

100
singleton/prop_utils_2d.cpp
View File

@ -46,19 +46,19 @@ SOFTWARE.
#include "core/engine.h" #include "core/engine.h"
#endif #endif
PropUtils *PropUtils::_instance; PropUtils2D *PropUtils2D::_instance;
Vector<Ref<PropDataEntry> > PropUtils::_processors; Vector<Ref<PropDataEntry2D> > PropUtils2D::_processors;
PropUtils *PropUtils::get_singleton() { PropUtils2D *PropUtils2D::get_singleton() {
return _instance; return _instance;
} }
Ref<PropData> PropUtils::convert_tree(Node *root) { Ref<PropData2D> PropUtils2D::convert_tree(Node *root) {
#if VERSION_MAJOR < 4 #if VERSION_MAJOR < 4
ERR_FAIL_COND_V(!ObjectDB::instance_validate(root), Ref<PropData>()); ERR_FAIL_COND_V(!ObjectDB::instance_validate(root), Ref<PropData2D>());
#endif #endif
Ref<PropData> data; Ref<PropData2D> data;
data.instance(); data.instance();
Transform t; Transform t;
@ -67,13 +67,13 @@ Ref<PropData> PropUtils::convert_tree(Node *root) {
return data; return data;
} }
void PropUtils::_convert_tree(Ref<PropData> prop_data, Node *node, const Transform &transform) { void PropUtils2D::_convert_tree(Ref<PropData2D> prop_data, Node *node, const Transform &transform) {
#if VERSION_MAJOR < 4 #if VERSION_MAJOR < 4
ERR_FAIL_COND(!ObjectDB::instance_validate(node)); ERR_FAIL_COND(!ObjectDB::instance_validate(node));
#endif #endif
for (int i = 0; i < PropUtils::_processors.size(); ++i) { for (int i = 0; i < PropUtils2D::_processors.size(); ++i) {
Ref<PropDataEntry> proc = PropUtils::_processors.get(i); Ref<PropDataEntry2D> proc = PropUtils2D::_processors.get(i);
ERR_CONTINUE(!proc.is_valid()); ERR_CONTINUE(!proc.is_valid());
@ -138,7 +138,7 @@ void PropUtils::_convert_tree(Ref<PropData> prop_data, Node *node, const Transfo
} }
#if VERSION_MINOR >= 4 #if VERSION_MINOR >= 4
bool PropUtils::generate_room_points_node(Node *node) { bool PropUtils2D::generate_room_points_node(Node *node) {
ERR_FAIL_COND_V(!ObjectDB::instance_validate(node), false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(node), false);
Room *r = Object::cast_to<Room>(node); Room *r = Object::cast_to<Room>(node);
@ -158,7 +158,7 @@ bool PropUtils::generate_room_points_node(Node *node) {
return false; return false;
} }
void PropUtils::generate_room_points(Room *room) { void PropUtils2D::generate_room_points(Room *room) {
ERR_FAIL_COND(!ObjectDB::instance_validate(room)); ERR_FAIL_COND(!ObjectDB::instance_validate(room));
Vector<PoolVector<Vector3> > mesh_arrays; Vector<PoolVector<Vector3> > mesh_arrays;
@ -281,7 +281,7 @@ void PropUtils::generate_room_points(Room *room) {
} }
//based on Room::SimplifyInfo::add_plane_if_unique //based on Room::SimplifyInfo::add_plane_if_unique
bool PropUtils::is_plane_unique(const PoolVector<Plane> &planes, const Plane &p) { bool PropUtils2D::is_plane_unique(const PoolVector<Plane> &planes, const Plane &p) {
for (int n = 0; n < planes.size(); n++) { for (int n = 0; n < planes.size(); n++) {
const Plane &o = planes[n]; const Plane &o = planes[n];
@ -306,7 +306,7 @@ bool PropUtils::is_plane_unique(const PoolVector<Plane> &planes, const Plane &p)
return true; return true;
} }
void PropUtils::get_mesh_arrays(Node *node, Vector<PoolVector<Vector3> > *arrs) { void PropUtils2D::get_mesh_arrays(Node *node, Vector<PoolVector<Vector3> > *arrs) {
ERR_FAIL_COND(!ObjectDB::instance_validate(node)); ERR_FAIL_COND(!ObjectDB::instance_validate(node));
for (int i = 0; i < node->get_child_count(); ++i) { for (int i = 0; i < node->get_child_count(); ++i) {
@ -462,67 +462,67 @@ void PropUtils::get_mesh_arrays(Node *node, Vector<PoolVector<Vector3> > *arrs)
#endif #endif
int PropUtils::add_processor(const Ref<PropDataEntry> &processor) { int PropUtils2D::add_processor(const Ref<PropDataEntry2D> &processor) {
ERR_FAIL_COND_V(!processor.is_valid(), 0); ERR_FAIL_COND_V(!processor.is_valid(), 0);
PropUtils::_processors.push_back(processor); PropUtils2D::_processors.push_back(processor);
return PropUtils::_processors.size() - 1; return PropUtils2D::_processors.size() - 1;
} }
Ref<PropDataEntry> PropUtils::get_processor(const int index) { Ref<PropDataEntry2D> PropUtils2D::get_processor(const int index) {
ERR_FAIL_INDEX_V(index, PropUtils::_processors.size(), Ref<PropDataEntry>()); ERR_FAIL_INDEX_V(index, PropUtils2D::_processors.size(), Ref<PropDataEntry2D>());
return PropUtils::_processors[index]; return PropUtils2D::_processors[index];
} }
void PropUtils::swap_processors(const int index1, const int index2) { void PropUtils2D::swap_processors(const int index1, const int index2) {
ERR_FAIL_INDEX(index1, PropUtils::_processors.size()); ERR_FAIL_INDEX(index1, PropUtils2D::_processors.size());
ERR_FAIL_INDEX(index2, PropUtils::_processors.size()); ERR_FAIL_INDEX(index2, PropUtils2D::_processors.size());
Ref<PropDataEntry> a = PropUtils::_processors.get(index1); Ref<PropDataEntry2D> a = PropUtils2D::_processors.get(index1);
PropUtils::_processors.set(index1, PropUtils::_processors.get(index2)); PropUtils2D::_processors.set(index1, PropUtils2D::_processors.get(index2));
PropUtils::_processors.set(index2, a); PropUtils2D::_processors.set(index2, a);
} }
void PropUtils::remove_processor(const int index) { void PropUtils2D::remove_processor(const int index) {
ERR_FAIL_INDEX(index, PropUtils::_processors.size()); ERR_FAIL_INDEX(index, PropUtils2D::_processors.size());
PropUtils::_processors.remove(index); PropUtils2D::_processors.remove(index);
} }
int PropUtils::get_processor_count() { int PropUtils2D::get_processor_count() {
return PropUtils::_processors.size(); return PropUtils2D::_processors.size();
} }
PropUtils::PropUtils() { PropUtils2D::PropUtils2D() {
_instance = this; _instance = this;
} }
PropUtils::~PropUtils() { PropUtils2D::~PropUtils2D() {
_instance = NULL; _instance = NULL;
PropUtils::_processors.clear(); PropUtils2D::_processors.clear();
} }
void PropUtils::_bind_methods() { void PropUtils2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("convert_tree", "root"), &PropUtils::convert_tree); ClassDB::bind_method(D_METHOD("convert_tree", "root"), &PropUtils2D::convert_tree);
ClassDB::bind_method(D_METHOD("add_processor", "processor"), &PropUtils::_add_processor_bind); ClassDB::bind_method(D_METHOD("add_processor", "processor"), &PropUtils2D::_add_processor_bind);
ClassDB::bind_method(D_METHOD("get_processor", "index"), &PropUtils::_get_processor_bind); ClassDB::bind_method(D_METHOD("get_processor", "index"), &PropUtils2D::_get_processor_bind);
ClassDB::bind_method(D_METHOD("swap_processors", "index1", "index2"), &PropUtils::_swap_processors_bind); ClassDB::bind_method(D_METHOD("swap_processors", "index1", "index2"), &PropUtils2D::_swap_processors_bind);
ClassDB::bind_method(D_METHOD("remove_processor", "index"), &PropUtils::_remove_processor_bind); ClassDB::bind_method(D_METHOD("remove_processor", "index"), &PropUtils2D::_remove_processor_bind);
ClassDB::bind_method(D_METHOD("get_processor_count"), &PropUtils::_get_processor_count_bind); ClassDB::bind_method(D_METHOD("get_processor_count"), &PropUtils2D::_get_processor_count_bind);
} }
int PropUtils::_add_processor_bind(const Ref<PropDataEntry> &processor) { int PropUtils2D::_add_processor_bind(const Ref<PropDataEntry2D> &processor) {
return PropUtils::add_processor(processor); return PropUtils2D::add_processor(processor);
} }
Ref<PropDataEntry> PropUtils::_get_processor_bind(const int index) { Ref<PropDataEntry2D> PropUtils2D::_get_processor_bind(const int index) {
return PropUtils::get_processor(index); return PropUtils2D::get_processor(index);
} }
void PropUtils::_swap_processors_bind(const int index1, const int index2) { void PropUtils2D::_swap_processors_bind(const int index1, const int index2) {
PropUtils::swap_processors(index1, index2); PropUtils2D::swap_processors(index1, index2);
} }
void PropUtils::_remove_processor_bind(const int index) { void PropUtils2D::_remove_processor_bind(const int index) {
PropUtils::remove_processor(index); PropUtils2D::remove_processor(index);
} }
int PropUtils::_get_processor_count_bind() { int PropUtils2D::_get_processor_count_bind() {
return PropUtils::get_processor_count(); return PropUtils2D::get_processor_count();
} }

30
singleton/prop_utils_2d.h
View File

@ -39,21 +39,21 @@ SOFTWARE.
#include "scene/main/node.h" #include "scene/main/node.h"
class PropData; class PropData2D;
class PropDataEntry; class PropDataEntry2D;
#if VERSION_MINOR >= 4 #if VERSION_MINOR >= 4
class Room; class Room;
#endif #endif
class PropUtils : public Object { class PropUtils2D : public Object {
GDCLASS(PropUtils, Object); GDCLASS(PropUtils2D, Object);
public: public:
static PropUtils *get_singleton(); static PropUtils2D *get_singleton();
Ref<PropData> convert_tree(Node *root); Ref<PropData2D> convert_tree(Node *root);
void _convert_tree(Ref<PropData> prop_data, Node *node, const Transform &transform); void _convert_tree(Ref<PropData2D> prop_data, Node *node, const Transform &transform);
#if VERSION_MINOR >= 4 #if VERSION_MINOR >= 4
bool generate_room_points_node(Node *node); bool generate_room_points_node(Node *node);
@ -62,27 +62,27 @@ public:
bool is_plane_unique(const PoolVector<Plane> &planes, const Plane &p); bool is_plane_unique(const PoolVector<Plane> &planes, const Plane &p);
#endif #endif
static int add_processor(const Ref<PropDataEntry> &processor); static int add_processor(const Ref<PropDataEntry2D> &processor);
static Ref<PropDataEntry> get_processor(const int index); static Ref<PropDataEntry2D> get_processor(const int index);
static void swap_processors(const int index1, const int index2); static void swap_processors(const int index1, const int index2);
static void remove_processor(const int index); static void remove_processor(const int index);
static int get_processor_count(); static int get_processor_count();
PropUtils(); PropUtils2D();
~PropUtils(); ~PropUtils2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();
private: private:
int _add_processor_bind(const Ref<PropDataEntry> &processor); int _add_processor_bind(const Ref<PropDataEntry2D> &processor);
Ref<PropDataEntry> _get_processor_bind(const int index); Ref<PropDataEntry2D> _get_processor_bind(const int index);
void _swap_processors_bind(const int index1, const int index2); void _swap_processors_bind(const int index1, const int index2);
void _remove_processor_bind(const int index); void _remove_processor_bind(const int index);
int _get_processor_count_bind(); int _get_processor_count_bind();
static Vector<Ref<PropDataEntry>> _processors; static Vector<Ref<PropDataEntry2D>> _processors;
static PropUtils *_instance; static PropUtils2D *_instance;
}; };
#endif #endif

92
tiled_wall/tiled_wall_2d.cpp
View File

@ -25,30 +25,30 @@
#include "core/core_string_names.h" #include "core/core_string_names.h"
#include "tiled_wall_data_2d.h" #include "tiled_wall_data_2d.h"
int TiledWall::get_width() const { int TiledWall2D::get_width() const {
return _width; return _width;
} }
void TiledWall::set_width(const int value) { void TiledWall2D::set_width(const int value) {
_width = value; _width = value;
clear_mesh(); clear_mesh();
generate_mesh(); generate_mesh();
} }
int TiledWall::get_heigth() const { int TiledWall2D::get_heigth() const {
return _height; return _height;
} }
void TiledWall::set_heigth(const int value) { void TiledWall2D::set_heigth(const int value) {
_height = value; _height = value;
clear_mesh(); clear_mesh();
generate_mesh(); generate_mesh();
} }
Ref<TiledWallData> TiledWall::get_data() { Ref<TiledWallData2D> TiledWall2D::get_data() {
return _data; return _data;
} }
void TiledWall::set_data(const Ref<TiledWallData> &data) { void TiledWall2D::set_data(const Ref<TiledWallData2D> &data) {
if (_data.is_valid()) { if (_data.is_valid()) {
_data->disconnect(CoreStringNames::get_singleton()->changed, this, "refresh"); _data->disconnect(CoreStringNames::get_singleton()->changed, this, "refresh");
} }
@ -62,10 +62,10 @@ void TiledWall::set_data(const Ref<TiledWallData> &data) {
call_deferred("refresh"); call_deferred("refresh");
} }
bool TiledWall::get_collision() const { bool TiledWall2D::get_collision() const {
return _collision; return _collision;
} }
void TiledWall::set_collision(const int value) { void TiledWall2D::set_collision(const int value) {
_collision = value; _collision = value;
/* /*
@ -80,11 +80,11 @@ void TiledWall::set_collision(const int value) {
}*/ }*/
} }
uint32_t TiledWall::get_collision_layer() const { uint32_t TiledWall2D::get_collision_layer() const {
return _collision_layer; return _collision_layer;
} }
void TiledWall::set_collision_layer(uint32_t p_layer) { void TiledWall2D::set_collision_layer(uint32_t p_layer) {
_collision_layer = p_layer; _collision_layer = p_layer;
if (_physics_body_rid != RID()) { if (_physics_body_rid != RID()) {
@ -92,11 +92,11 @@ void TiledWall::set_collision_layer(uint32_t p_layer) {
} }
} }
uint32_t TiledWall::get_collision_mask() const { uint32_t TiledWall2D::get_collision_mask() const {
return _collision_mask; return _collision_mask;
} }
void TiledWall::set_collision_mask(uint32_t p_mask) { void TiledWall2D::set_collision_mask(uint32_t p_mask) {
_collision_mask = p_mask; _collision_mask = p_mask;
if (_physics_body_rid != RID()) { if (_physics_body_rid != RID()) {
@ -104,11 +104,11 @@ void TiledWall::set_collision_mask(uint32_t p_mask) {
} }
} }
AABB TiledWall::get_aabb() const { AABB TiledWall2D::get_aabb() const {
return AABB(); return AABB();
} }
PoolVector<Face3> TiledWall::get_faces(uint32_t p_usage_flags) const { PoolVector<Face3> TiledWall2D::get_faces(uint32_t p_usage_flags) const {
PoolVector<Face3> faces; PoolVector<Face3> faces;
if (_mesh_array.size() != Mesh::ARRAY_MAX) { if (_mesh_array.size() != Mesh::ARRAY_MAX) {
@ -138,7 +138,7 @@ PoolVector<Face3> TiledWall::get_faces(uint32_t p_usage_flags) const {
return faces; return faces;
} }
void TiledWall::refresh() { void TiledWall2D::refresh() {
if (!is_inside_tree()) { if (!is_inside_tree()) {
return; return;
} }
@ -163,14 +163,14 @@ void TiledWall::refresh() {
VS::get_singleton()->instance_set_base(get_instance(), _mesh_rid); VS::get_singleton()->instance_set_base(get_instance(), _mesh_rid);
} }
Ref<PropMaterialCache> old_cache; Ref<PropMaterialCache2D> old_cache;
old_cache = _cache; old_cache = _cache;
_cache = PropCache::get_singleton()->tiled_wall_material_cache_get(_data); _cache = PropCache2D::get_singleton()->tiled_wall_material_cache_get(_data);
if (old_cache.is_valid() && old_cache != _cache) { if (old_cache.is_valid() && old_cache != _cache) {
PropCache::get_singleton()->tiled_wall_material_cache_unref(old_cache); PropCache2D::get_singleton()->tiled_wall_material_cache_unref(old_cache);
} }
if (!_cache->get_initialized()) { if (!_cache->get_initialized()) {
@ -192,7 +192,7 @@ void TiledWall::refresh() {
generate_mesh(); generate_mesh();
} }
void TiledWall::generate_mesh() { void TiledWall2D::generate_mesh() {
if (!_data.is_valid()) { if (!_data.is_valid()) {
return; return;
} }
@ -234,7 +234,7 @@ void TiledWall::generate_mesh() {
_aabb.size = Vector3(_width, _height, 0); _aabb.size = Vector3(_width, _height, 0);
} }
void TiledWall::clear_mesh() { void TiledWall2D::clear_mesh() {
_mesher->reset(); _mesher->reset();
_aabb = AABB(); _aabb = AABB();
_mesh_array.clear(); _mesh_array.clear();
@ -249,7 +249,7 @@ void TiledWall::clear_mesh() {
} }
} }
void TiledWall::free_mesh() { void TiledWall2D::free_mesh() {
if (_mesh_rid != RID()) { if (_mesh_rid != RID()) {
VS::get_singleton()->instance_set_base(get_instance(), RID()); VS::get_singleton()->instance_set_base(get_instance(), RID());
VS::get_singleton()->free(_mesh_rid); VS::get_singleton()->free(_mesh_rid);
@ -257,7 +257,7 @@ void TiledWall::free_mesh() {
} }
} }
void TiledWall::create_colliders() { void TiledWall2D::create_colliders() {
if (!is_inside_tree()) { if (!is_inside_tree()) {
return; return;
} }
@ -272,7 +272,7 @@ void TiledWall::create_colliders() {
PhysicsServer::get_singleton()->body_add_shape(_physics_body_rid, _physics_shape_rid); PhysicsServer::get_singleton()->body_add_shape(_physics_body_rid, _physics_shape_rid);
} }
void TiledWall::free_colliders() { void TiledWall2D::free_colliders() {
if (_physics_shape_rid != RID()) { if (_physics_shape_rid != RID()) {
PhysicsServer::get_singleton()->free(_physics_shape_rid); PhysicsServer::get_singleton()->free(_physics_shape_rid);
@ -280,7 +280,7 @@ void TiledWall::free_colliders() {
} }
} }
TiledWall::TiledWall() { TiledWall2D::TiledWall2D() {
_width = 1; _width = 1;
_height = 1; _height = 1;
_collision = true; _collision = true;
@ -296,7 +296,7 @@ TiledWall::TiledWall() {
_mesher.instance(); _mesher.instance();
} }
TiledWall::~TiledWall() { TiledWall2D::~TiledWall2D() {
_data.unref(); _data.unref();
_cache.unref(); _cache.unref();
_mesher.unref(); _mesher.unref();
@ -309,7 +309,7 @@ TiledWall::~TiledWall() {
free_colliders(); free_colliders();
} }
void TiledWall::_notification(int p_what) { void TiledWall2D::_notification(int p_what) {
switch (p_what) { switch (p_what) {
case NOTIFICATION_ENTER_WORLD: { case NOTIFICATION_ENTER_WORLD: {
Transform t = get_global_transform(); Transform t = get_global_transform();
@ -341,38 +341,38 @@ void TiledWall::_notification(int p_what) {
} }
} }
void TiledWall::_bind_methods() { void TiledWall2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_width"), &TiledWall::get_width); ClassDB::bind_method(D_METHOD("get_width"), &TiledWall2D::get_width);
ClassDB::bind_method(D_METHOD("set_width", "value"), &TiledWall::set_width); ClassDB::bind_method(D_METHOD("set_width", "value"), &TiledWall2D::set_width);
ADD_PROPERTY(PropertyInfo(Variant::INT, "width"), "set_width", "get_width"); ADD_PROPERTY(PropertyInfo(Variant::INT, "width"), "set_width", "get_width");
ClassDB::bind_method(D_METHOD("get_heigth"), &TiledWall::get_heigth); ClassDB::bind_method(D_METHOD("get_heigth"), &TiledWall2D::get_heigth);
ClassDB::bind_method(D_METHOD("set_heigth", "value"), &TiledWall::set_heigth); ClassDB::bind_method(D_METHOD("set_heigth", "value"), &TiledWall2D::set_heigth);
ADD_PROPERTY(PropertyInfo(Variant::INT, "heigth"), "set_heigth", "get_heigth"); ADD_PROPERTY(PropertyInfo(Variant::INT, "heigth"), "set_heigth", "get_heigth");
ClassDB::bind_method(D_METHOD("get_data"), &TiledWall::get_data); ClassDB::bind_method(D_METHOD("get_data"), &TiledWall2D::get_data);
ClassDB::bind_method(D_METHOD("set_data", "value"), &TiledWall::set_data); ClassDB::bind_method(D_METHOD("set_data", "value"), &TiledWall2D::set_data);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "TiledWallData"), "set_data", "get_data"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "TiledWallData2D"), "set_data", "get_data");
ClassDB::bind_method(D_METHOD("get_collision"), &TiledWall::get_collision); ClassDB::bind_method(D_METHOD("get_collision"), &TiledWall2D::get_collision);
ClassDB::bind_method(D_METHOD("set_collision", "value"), &TiledWall::set_collision); ClassDB::bind_method(D_METHOD("set_collision", "value"), &TiledWall2D::set_collision);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collision"), "set_collision", "get_collision"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collision"), "set_collision", "get_collision");
ClassDB::bind_method(D_METHOD("get_collision_layer"), &TiledWall::get_collision_layer); ClassDB::bind_method(D_METHOD("get_collision_layer"), &TiledWall2D::get_collision_layer);
ClassDB::bind_method(D_METHOD("set_collision_layer", "value"), &TiledWall::set_collision_layer); ClassDB::bind_method(D_METHOD("set_collision_layer", "value"), &TiledWall2D::set_collision_layer);
ClassDB::bind_method(D_METHOD("get_collision_mask"), &TiledWall::get_collision_mask); ClassDB::bind_method(D_METHOD("get_collision_mask"), &TiledWall2D::get_collision_mask);
ClassDB::bind_method(D_METHOD("set_collision_mask", "value"), &TiledWall::set_collision_mask); ClassDB::bind_method(D_METHOD("set_collision_mask", "value"), &TiledWall2D::set_collision_mask);
ADD_GROUP("Collision", "collision_"); ADD_GROUP("Collision", "collision_");
ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_layer", "get_collision_layer"); ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_layer", "get_collision_layer");
ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_mask", "get_collision_mask"); ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_mask", "get_collision_mask");
ClassDB::bind_method(D_METHOD("refresh"), &TiledWall::refresh); ClassDB::bind_method(D_METHOD("refresh"), &TiledWall2D::refresh);
ClassDB::bind_method(D_METHOD("generate_mesh"), &TiledWall::generate_mesh); ClassDB::bind_method(D_METHOD("generate_mesh"), &TiledWall2D::generate_mesh);
ClassDB::bind_method(D_METHOD("clear_mesh"), &TiledWall::clear_mesh); ClassDB::bind_method(D_METHOD("clear_mesh"), &TiledWall2D::clear_mesh);
ClassDB::bind_method(D_METHOD("free_mesh"), &TiledWall::free_mesh); ClassDB::bind_method(D_METHOD("free_mesh"), &TiledWall2D::free_mesh);
ClassDB::bind_method(D_METHOD("create_colliders"), &TiledWall::create_colliders); ClassDB::bind_method(D_METHOD("create_colliders"), &TiledWall2D::create_colliders);
ClassDB::bind_method(D_METHOD("free_colliders"), &TiledWall::free_colliders); ClassDB::bind_method(D_METHOD("free_colliders"), &TiledWall2D::free_colliders);
} }

24
tiled_wall/tiled_wall_2d.h
View File

@ -38,12 +38,12 @@ SOFTWARE.
#include "core/math/vector3.h" #include "core/math/vector3.h"
class TiledWallData; class TiledWallData2D;
class PropMaterialCache; class PropMaterialCache2D;
class PropMesher; class PropMesher2D;
class TiledWall : public GeometryInstance { class TiledWall2D : public GeometryInstance {
GDCLASS(TiledWall, GeometryInstance); GDCLASS(TiledWall2D, GeometryInstance);
public: public:
int get_width() const; int get_width() const;
@ -52,8 +52,8 @@ public:
int get_heigth() const; int get_heigth() const;
void set_heigth(const int value); void set_heigth(const int value);
Ref<TiledWallData> get_data(); Ref<TiledWallData2D> get_data();
void set_data(const Ref<TiledWallData> &data); void set_data(const Ref<TiledWallData2D> &data);
bool get_collision() const; bool get_collision() const;
void set_collision(const int value); void set_collision(const int value);
@ -75,8 +75,8 @@ public:
void create_colliders(); void create_colliders();
void free_colliders(); void free_colliders();
TiledWall(); TiledWall2D();
~TiledWall(); ~TiledWall2D();
protected: protected:
void _notification(int p_what); void _notification(int p_what);
@ -90,9 +90,9 @@ private:
uint32_t _collision_layer; uint32_t _collision_layer;
uint32_t _collision_mask; uint32_t _collision_mask;
Ref<TiledWallData> _data; Ref<TiledWallData2D> _data;
Ref<PropMaterialCache> _cache; Ref<PropMaterialCache2D> _cache;
Ref<PropMesher> _mesher; Ref<PropMesher2D> _mesher;
AABB _aabb; AABB _aabb;
RID _mesh_rid; RID _mesh_rid;

128
tiled_wall/tiled_wall_data_2d.cpp
View File

@ -59,33 +59,33 @@ SOFTWARE.
#include "../material_cache/prop_material_cache_2d.h" #include "../material_cache/prop_material_cache_2d.h"
const String TiledWallData::BINDING_STRING_TILED_WALL_TILING_TYPE = "None,Horizontal,Vertical,Both"; const String TiledWallData2D::BINDING_STRING_TILED_WALL_TILING_TYPE = "None,Horizontal,Vertical,Both";
TiledWallData::TiledWallTilingType TiledWallData::get_tiling_type() const { TiledWallData2D::TiledWallTilingType TiledWallData2D::get_tiling_type() const {
return _tiling_type; return _tiling_type;
} }
void TiledWallData::set_tiling_type(const TiledWallData::TiledWallTilingType value) { void TiledWallData2D::set_tiling_type(const TiledWallData2D::TiledWallTilingType value) {
_tiling_type = value; _tiling_type = value;
emit_changed(); emit_changed();
} }
Ref<Texture> TiledWallData::get_texture(const int index) const { Ref<Texture> TiledWallData2D::get_texture(const int index) const {
ERR_FAIL_INDEX_V(index, _textures.size(), Ref<Texture>()); ERR_FAIL_INDEX_V(index, _textures.size(), Ref<Texture>());
return _textures.get(index); return _textures.get(index);
} }
void TiledWallData::set_texture(const int index, const Ref<Texture> &texture) { void TiledWallData2D::set_texture(const int index, const Ref<Texture> &texture) {
ERR_FAIL_INDEX(index, _textures.size()); ERR_FAIL_INDEX(index, _textures.size());
_textures.set(index, texture); _textures.set(index, texture);
emit_changed(); emit_changed();
} }
void TiledWallData::add_texture(const Ref<Texture> &texture) { void TiledWallData2D::add_texture(const Ref<Texture> &texture) {
_textures.push_back(texture); _textures.push_back(texture);
} }
void TiledWallData::remove_texture(const int index) { void TiledWallData2D::remove_texture(const int index) {
ERR_FAIL_INDEX(index, _textures.size()); ERR_FAIL_INDEX(index, _textures.size());
_textures.remove(index); _textures.remove(index);
@ -93,11 +93,11 @@ void TiledWallData::remove_texture(const int index) {
emit_changed(); emit_changed();
} }
int TiledWallData::get_texture_count() const { int TiledWallData2D::get_texture_count() const {
return _textures.size(); return _textures.size();
} }
Vector<Variant> TiledWallData::get_textures() { Vector<Variant> TiledWallData2D::get_textures() {
Vector<Variant> r; Vector<Variant> r;
for (int i = 0; i < _textures.size(); i++) { for (int i = 0; i < _textures.size(); i++) {
#if VERSION_MAJOR < 4 #if VERSION_MAJOR < 4
@ -108,7 +108,7 @@ Vector<Variant> TiledWallData::get_textures() {
} }
return r; return r;
} }
void TiledWallData::set_textures(const Vector<Variant> &textures) { void TiledWallData2D::set_textures(const Vector<Variant> &textures) {
_textures.clear(); _textures.clear();
for (int i = 0; i < textures.size(); i++) { for (int i = 0; i < textures.size(); i++) {
Ref<Texture> tex = Ref<Texture>(textures[i]); Ref<Texture> tex = Ref<Texture>(textures[i]);
@ -118,22 +118,22 @@ void TiledWallData::set_textures(const Vector<Variant> &textures) {
} }
//flavour_textures //flavour_textures
Ref<Texture> TiledWallData::get_flavour_texture(const int index) const { Ref<Texture> TiledWallData2D::get_flavour_texture(const int index) const {
ERR_FAIL_INDEX_V(index, _flavour_textures.size(), Ref<Texture>()); ERR_FAIL_INDEX_V(index, _flavour_textures.size(), Ref<Texture>());
return _flavour_textures.get(index); return _flavour_textures.get(index);
} }
void TiledWallData::set_flavour_texture(const int index, const Ref<Texture> &texture) { void TiledWallData2D::set_flavour_texture(const int index, const Ref<Texture> &texture) {
ERR_FAIL_INDEX(index, _flavour_textures.size()); ERR_FAIL_INDEX(index, _flavour_textures.size());
_flavour_textures.set(index, texture); _flavour_textures.set(index, texture);
emit_changed(); emit_changed();
} }
void TiledWallData::add_flavour_texture(const Ref<Texture> &texture) { void TiledWallData2D::add_flavour_texture(const Ref<Texture> &texture) {
_flavour_textures.push_back(texture); _flavour_textures.push_back(texture);
} }
void TiledWallData::remove_flavour_texture(const int index) { void TiledWallData2D::remove_flavour_texture(const int index) {
ERR_FAIL_INDEX(index, _flavour_textures.size()); ERR_FAIL_INDEX(index, _flavour_textures.size());
_flavour_textures.remove(index); _flavour_textures.remove(index);
@ -141,11 +141,11 @@ void TiledWallData::remove_flavour_texture(const int index) {
emit_changed(); emit_changed();
} }
int TiledWallData::get_flavour_texture_count() const { int TiledWallData2D::get_flavour_texture_count() const {
return _flavour_textures.size(); return _flavour_textures.size();
} }
Vector<Variant> TiledWallData::get_flavour_textures() { Vector<Variant> TiledWallData2D::get_flavour_textures() {
Vector<Variant> r; Vector<Variant> r;
for (int i = 0; i < _flavour_textures.size(); i++) { for (int i = 0; i < _flavour_textures.size(); i++) {
#if VERSION_MAJOR < 4 #if VERSION_MAJOR < 4
@ -156,7 +156,7 @@ Vector<Variant> TiledWallData::get_flavour_textures() {
} }
return r; return r;
} }
void TiledWallData::set_flavour_textures(const Vector<Variant> &textures) { void TiledWallData2D::set_flavour_textures(const Vector<Variant> &textures) {
_flavour_textures.clear(); _flavour_textures.clear();
for (int i = 0; i < textures.size(); i++) { for (int i = 0; i < textures.size(); i++) {
Ref<Texture> tex = Ref<Texture>(textures[i]); Ref<Texture> tex = Ref<Texture>(textures[i]);
@ -167,21 +167,21 @@ void TiledWallData::set_flavour_textures(const Vector<Variant> &textures) {
emit_changed(); emit_changed();
} }
float TiledWallData::get_flavour_chance() const { float TiledWallData2D::get_flavour_chance() const {
return _flavour_chance; return _flavour_chance;
} }
void TiledWallData::set_flavour_chance(const float value) { void TiledWallData2D::set_flavour_chance(const float value) {
_flavour_chance = value; _flavour_chance = value;
} }
//materials //materials
void TiledWallData::material_add(const Ref<Material> &value) { void TiledWallData2D::material_add(const Ref<Material> &value) {
ERR_FAIL_COND(!value.is_valid()); ERR_FAIL_COND(!value.is_valid());
_materials.push_back(value); _materials.push_back(value);
} }
void TiledWallData::material_set(const int index, const Ref<Material> &value) { void TiledWallData2D::material_set(const int index, const Ref<Material> &value) {
ERR_FAIL_INDEX(index, _materials.size()); ERR_FAIL_INDEX(index, _materials.size());
_materials.set(index, value); _materials.set(index, value);
@ -189,25 +189,25 @@ void TiledWallData::material_set(const int index, const Ref<Material> &value) {
emit_changed(); emit_changed();
} }
void TiledWallData::material_remove(const int index) { void TiledWallData2D::material_remove(const int index) {
_materials.remove(index); _materials.remove(index);
emit_changed(); emit_changed();
} }
int TiledWallData::material_get_num() const { int TiledWallData2D::material_get_num() const {
return _materials.size(); return _materials.size();
} }
void TiledWallData::materials_clear() { void TiledWallData2D::materials_clear() {
_materials.clear(); _materials.clear();
} }
Vector<Variant> TiledWallData::materials_get() { Vector<Variant> TiledWallData2D::materials_get() {
VARIANT_ARRAY_GET(_materials); VARIANT_ARRAY_GET(_materials);
} }
void TiledWallData::materials_set(const Vector<Variant> &materials) { void TiledWallData2D::materials_set(const Vector<Variant> &materials) {
_materials.clear(); _materials.clear();
for (int i = 0; i < materials.size(); i++) { for (int i = 0; i < materials.size(); i++) {
@ -220,7 +220,7 @@ void TiledWallData::materials_set(const Vector<Variant> &materials) {
} }
#if TEXTURE_PACKER_PRESENT #if TEXTURE_PACKER_PRESENT
void TiledWallData::add_textures_into(Ref<TexturePacker> texture_packer) { void TiledWallData2D::add_textures_into(Ref<TexturePacker> texture_packer) {
ERR_FAIL_COND(!texture_packer.is_valid()); ERR_FAIL_COND(!texture_packer.is_valid());
for (int i = 0; i < _textures.size(); ++i) { for (int i = 0; i < _textures.size(); ++i) {
@ -241,12 +241,12 @@ void TiledWallData::add_textures_into(Ref<TexturePacker> texture_packer) {
} }
#endif #endif
void TiledWallData::setup_cache(Ref<PropMaterialCache> cache) { void TiledWallData2D::setup_cache(Ref<PropMaterialCache2D> cache) {
//Note: the caller should lock and unlock the cache! //Note: the caller should lock and unlock the cache!
call("_setup_cache", cache); call("_setup_cache", cache);
} }
void TiledWallData::_setup_cache(Ref<PropMaterialCache> cache) { void TiledWallData2D::_setup_cache(Ref<PropMaterialCache2D> cache) {
if (cache->material_get_num() == 0) { if (cache->material_get_num() == 0) {
for (int i = 0; i < _materials.size(); ++i) { for (int i = 0; i < _materials.size(); ++i) {
const Ref<Material> &m = _materials[i]; const Ref<Material> &m = _materials[i];
@ -276,7 +276,7 @@ void TiledWallData::_setup_cache(Ref<PropMaterialCache> cache) {
} }
} }
void TiledWallData::copy_from(const Ref<TiledWallData> &tiled_wall_data) { void TiledWallData2D::copy_from(const Ref<TiledWallData2D> &tiled_wall_data) {
ERR_FAIL_COND(!tiled_wall_data.is_valid()); ERR_FAIL_COND(!tiled_wall_data.is_valid());
_tiling_type = tiled_wall_data->_tiling_type; _tiling_type = tiled_wall_data->_tiling_type;
@ -296,70 +296,70 @@ void TiledWallData::copy_from(const Ref<TiledWallData> &tiled_wall_data) {
emit_changed(); emit_changed();
} }
TiledWallData::TiledWallData() { TiledWallData2D::TiledWallData2D() {
_tiling_type = TILED_WALL_TILING_TYPE_NONE; _tiling_type = TILED_WALL_TILING_TYPE_NONE;
_flavour_chance = 0.15; _flavour_chance = 0.15;
} }
TiledWallData::~TiledWallData() { TiledWallData2D::~TiledWallData2D() {
_textures.clear(); _textures.clear();
_flavour_textures.clear(); _flavour_textures.clear();
_materials.clear(); _materials.clear();
} }
void TiledWallData::_bind_methods() { void TiledWallData2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_tiling_type"), &TiledWallData::get_tiling_type); ClassDB::bind_method(D_METHOD("get_tiling_type"), &TiledWallData2D::get_tiling_type);
ClassDB::bind_method(D_METHOD("set_tiling_type", "texture"), &TiledWallData::set_tiling_type); ClassDB::bind_method(D_METHOD("set_tiling_type", "texture"), &TiledWallData2D::set_tiling_type);
ADD_PROPERTY(PropertyInfo(Variant::INT, "tiling_type", PROPERTY_HINT_ENUM, TiledWallData::BINDING_STRING_TILED_WALL_TILING_TYPE), "set_tiling_type", "get_tiling_type"); ADD_PROPERTY(PropertyInfo(Variant::INT, "tiling_type", PROPERTY_HINT_ENUM, TiledWallData2D::BINDING_STRING_TILED_WALL_TILING_TYPE), "set_tiling_type", "get_tiling_type");
//textures //textures
ClassDB::bind_method(D_METHOD("get_texture", "index"), &TiledWallData::get_texture); ClassDB::bind_method(D_METHOD("get_texture", "index"), &TiledWallData2D::get_texture);
ClassDB::bind_method(D_METHOD("set_texture", "index", "texture"), &TiledWallData::set_texture); ClassDB::bind_method(D_METHOD("set_texture", "index", "texture"), &TiledWallData2D::set_texture);
ClassDB::bind_method(D_METHOD("add_texture", "texture"), &TiledWallData::add_texture); ClassDB::bind_method(D_METHOD("add_texture", "texture"), &TiledWallData2D::add_texture);
ClassDB::bind_method(D_METHOD("remove_texture", "index"), &TiledWallData::remove_texture); ClassDB::bind_method(D_METHOD("remove_texture", "index"), &TiledWallData2D::remove_texture);
ClassDB::bind_method(D_METHOD("get_texture_count"), &TiledWallData::get_texture_count); ClassDB::bind_method(D_METHOD("get_texture_count"), &TiledWallData2D::get_texture_count);
ClassDB::bind_method(D_METHOD("get_textures"), &TiledWallData::get_textures); ClassDB::bind_method(D_METHOD("get_textures"), &TiledWallData2D::get_textures);
ClassDB::bind_method(D_METHOD("set_textures", "textures"), &TiledWallData::set_textures); ClassDB::bind_method(D_METHOD("set_textures", "textures"), &TiledWallData2D::set_textures);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "textures", PROPERTY_HINT_NONE, "17/17:Texture", PROPERTY_USAGE_DEFAULT, "Texture"), "set_textures", "get_textures"); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "textures", PROPERTY_HINT_NONE, "17/17:Texture", PROPERTY_USAGE_DEFAULT, "Texture"), "set_textures", "get_textures");
//flavour_textures //flavour_textures
ClassDB::bind_method(D_METHOD("get_flavour_texture", "index"), &TiledWallData::get_flavour_texture); ClassDB::bind_method(D_METHOD("get_flavour_texture", "index"), &TiledWallData2D::get_flavour_texture);
ClassDB::bind_method(D_METHOD("set_flavour_texture", "index", "texture"), &TiledWallData::set_flavour_texture); ClassDB::bind_method(D_METHOD("set_flavour_texture", "index", "texture"), &TiledWallData2D::set_flavour_texture);
ClassDB::bind_method(D_METHOD("add_tflavour_exture", "texture"), &TiledWallData::add_flavour_texture); ClassDB::bind_method(D_METHOD("add_tflavour_exture", "texture"), &TiledWallData2D::add_flavour_texture);
ClassDB::bind_method(D_METHOD("remove_flavour_texture", "index"), &TiledWallData::remove_flavour_texture); ClassDB::bind_method(D_METHOD("remove_flavour_texture", "index"), &TiledWallData2D::remove_flavour_texture);
ClassDB::bind_method(D_METHOD("get_flavour_texture_count"), &TiledWallData::get_flavour_texture_count); ClassDB::bind_method(D_METHOD("get_flavour_texture_count"), &TiledWallData2D::get_flavour_texture_count);
ClassDB::bind_method(D_METHOD("get_flavour_textures"), &TiledWallData::get_flavour_textures); ClassDB::bind_method(D_METHOD("get_flavour_textures"), &TiledWallData2D::get_flavour_textures);
ClassDB::bind_method(D_METHOD("set_flavour_textures", "textures"), &TiledWallData::set_flavour_textures); ClassDB::bind_method(D_METHOD("set_flavour_textures", "textures"), &TiledWallData2D::set_flavour_textures);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "flavour_textures", PROPERTY_HINT_NONE, "17/17:Texture", PROPERTY_USAGE_DEFAULT, "Texture"), "set_flavour_textures", "get_flavour_textures"); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "flavour_textures", PROPERTY_HINT_NONE, "17/17:Texture", PROPERTY_USAGE_DEFAULT, "Texture"), "set_flavour_textures", "get_flavour_textures");
ClassDB::bind_method(D_METHOD("get_flavour_chance"), &TiledWallData::get_flavour_chance); ClassDB::bind_method(D_METHOD("get_flavour_chance"), &TiledWallData2D::get_flavour_chance);
ClassDB::bind_method(D_METHOD("set_flavour_chance", "texture"), &TiledWallData::set_flavour_chance); ClassDB::bind_method(D_METHOD("set_flavour_chance", "texture"), &TiledWallData2D::set_flavour_chance);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "flavour_chance"), "set_flavour_chance", "get_flavour_chance"); ADD_PROPERTY(PropertyInfo(Variant::REAL, "flavour_chance"), "set_flavour_chance", "get_flavour_chance");
//materials //materials
ClassDB::bind_method(D_METHOD("material_add", "value"), &TiledWallData::material_add); ClassDB::bind_method(D_METHOD("material_add", "value"), &TiledWallData2D::material_add);
ClassDB::bind_method(D_METHOD("material_set", "index", "value"), &TiledWallData::material_set); ClassDB::bind_method(D_METHOD("material_set", "index", "value"), &TiledWallData2D::material_set);
ClassDB::bind_method(D_METHOD("material_remove", "index"), &TiledWallData::material_remove); ClassDB::bind_method(D_METHOD("material_remove", "index"), &TiledWallData2D::material_remove);
ClassDB::bind_method(D_METHOD("material_get_num"), &TiledWallData::material_get_num); ClassDB::bind_method(D_METHOD("material_get_num"), &TiledWallData2D::material_get_num);
ClassDB::bind_method(D_METHOD("materials_clear"), &TiledWallData::materials_clear); ClassDB::bind_method(D_METHOD("materials_clear"), &TiledWallData2D::materials_clear);
ClassDB::bind_method(D_METHOD("materials_get"), &TiledWallData::materials_get); ClassDB::bind_method(D_METHOD("materials_get"), &TiledWallData2D::materials_get);
ClassDB::bind_method(D_METHOD("materials_set"), &TiledWallData::materials_set); ClassDB::bind_method(D_METHOD("materials_set"), &TiledWallData2D::materials_set);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "materials_set", "materials_get"); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "materials_set", "materials_get");
#if TEXTURE_PACKER_PRESENT #if TEXTURE_PACKER_PRESENT
ClassDB::bind_method(D_METHOD("add_textures_into", "texture_packer"), &TiledWallData::add_textures_into); ClassDB::bind_method(D_METHOD("add_textures_into", "texture_packer"), &TiledWallData2D::add_textures_into);
#endif #endif
BIND_VMETHOD(MethodInfo("_setup_cache", PropertyInfo(Variant::OBJECT, "cache", PROPERTY_HINT_RESOURCE_TYPE, "PropMaterialCache"))); BIND_VMETHOD(MethodInfo("_setup_cache", PropertyInfo(Variant::OBJECT, "cache", PROPERTY_HINT_RESOURCE_TYPE, "PropMaterialCache2D")));
ClassDB::bind_method(D_METHOD("setup_cache", "cache"), &TiledWallData::setup_cache); ClassDB::bind_method(D_METHOD("setup_cache", "cache"), &TiledWallData2D::setup_cache);
ClassDB::bind_method(D_METHOD("_setup_cache", "cache"), &TiledWallData::_setup_cache); ClassDB::bind_method(D_METHOD("_setup_cache", "cache"), &TiledWallData2D::_setup_cache);
ClassDB::bind_method(D_METHOD("copy_from", "prop_data"), &TiledWallData::copy_from); ClassDB::bind_method(D_METHOD("copy_from", "prop_data"), &TiledWallData2D::copy_from);
BIND_ENUM_CONSTANT(TILED_WALL_TILING_TYPE_NONE); BIND_ENUM_CONSTANT(TILED_WALL_TILING_TYPE_NONE);
BIND_ENUM_CONSTANT(TILED_WALL_TILING_TYPE_HORIZONTAL); BIND_ENUM_CONSTANT(TILED_WALL_TILING_TYPE_HORIZONTAL);

20
tiled_wall/tiled_wall_data_2d.h
View File

@ -47,11 +47,11 @@ SOFTWARE.
#include "../../texture_packer/texture_packer.h" #include "../../texture_packer/texture_packer.h"
#endif #endif
class PropMaterialCache; class PropMaterialCache2D;
class PropMesher; class PropMesher2D;
class TiledWallData : public Resource { class TiledWallData2D : public Resource {
GDCLASS(TiledWallData, Resource); GDCLASS(TiledWallData2D, Resource);
public: public:
enum TiledWallTilingType { enum TiledWallTilingType {
@ -106,15 +106,15 @@ public:
void add_textures_into(Ref<TexturePacker> texture_packer); void add_textures_into(Ref<TexturePacker> texture_packer);
#endif #endif
void setup_cache(Ref<PropMaterialCache> cache); void setup_cache(Ref<PropMaterialCache2D> cache);
void _setup_cache(Ref<PropMaterialCache> cache); void _setup_cache(Ref<PropMaterialCache2D> cache);
void copy_from(const Ref<TiledWallData> &tiled_wall_data); void copy_from(const Ref<TiledWallData2D> &tiled_wall_data);
//Ref<Shape> get_collider_shape(); //Ref<Shape> get_collider_shape();
TiledWallData(); TiledWallData2D();
~TiledWallData(); ~TiledWallData2D();
protected: protected:
static void _bind_methods(); static void _bind_methods();
@ -129,6 +129,6 @@ private:
Vector<Ref<Material>> _materials; Vector<Ref<Material>> _materials;
}; };
VARIANT_ENUM_CAST(TiledWallData::TiledWallTilingType); VARIANT_ENUM_CAST(TiledWallData2D::TiledWallTilingType);
#endif #endif