Skip to content

Commit 6d5d8f4

Browse files
TokisanGamesTokisanGames
committed
Move region_size to Terrain3D
1 parent 37d47bf commit 6d5d8f4

8 files changed

+70
-71
lines changed

‎project/addons/terrain_3d/editor.gd

+2-3
Original file line numberDiff line numberDiff line change
@@ -180,9 +180,8 @@ func _forward_3d_gui_input(p_viewport_camera: Camera3D, p_event: InputEvent) ->
180180
ui.update_decal()
181181

182182
## Update region highlight
183-
var region_size = terrain.get_storage().get_region_size()
184183
var region_position: Vector2 = ( Vector2(mouse_global_position.x, mouse_global_position.z) \
185-
/ (region_size * terrain.get_mesh_vertex_spacing()) ).floor()
184+
/ (terrain.get_region_size() * terrain.get_mesh_vertex_spacing()) ).floor()
186185
if current_region_position != region_position:
187186
current_region_position = region_position
188187
update_region_grid()
@@ -246,7 +245,7 @@ func update_region_grid() -> void:
246245
region_gizmo.show_rect = editor.get_tool() == Terrain3DEditor.REGION
247246
region_gizmo.use_secondary_color = editor.get_operation() == Terrain3DEditor.SUBTRACT
248247
region_gizmo.region_position = current_region_position
249-
region_gizmo.region_size = terrain.get_storage().get_region_size() * terrain.get_mesh_vertex_spacing()
248+
region_gizmo.region_size = terrain.get_region_size() * terrain.get_mesh_vertex_spacing()
250249
region_gizmo.grid = terrain.get_storage().get_region_locations()
251250

252251
terrain.update_gizmos()

‎src/terrain_3d.cpp

+42-19
Original file line numberDiff line numberDiff line change
@@ -51,11 +51,6 @@ void Terrain3D::_initialize() {
5151
}
5252

5353
// Connect signals
54-
// Region size changed, update material
55-
if (!_storage->is_connected("region_size_changed", callable_mp(_material.ptr(), &Terrain3DMaterial::_update_maps))) {
56-
LOG(DEBUG, "Connecting region_size_changed signal to _material->_update_regions()");
57-
_storage->connect("region_size_changed", callable_mp(_material.ptr(), &Terrain3DMaterial::_update_maps));
58-
}
5954
// Any region was changed, update region labels
6055
if (!_storage->is_connected("region_map_changed", callable_mp(this, &Terrain3D::update_region_labels))) {
6156
LOG(DEBUG, "Connecting _storage::region_map_changed signal to set_show_region_locations()");
@@ -420,8 +415,7 @@ void Terrain3D::_update_collision() {
420415
}
421416

422417
int time = Time::get_singleton()->get_ticks_msec();
423-
int region_size = _storage->get_region_size();
424-
int shape_size = region_size + 1;
418+
int shape_size = _region_size + 1;
425419
float hole_const = NAN;
426420
// DEPRECATED - Jolt v0.12 supports NAN. Remove check when it's old.
427421
if (ProjectSettings::get_singleton()->get_setting("physics/3d/physics_engine") == "JoltPhysics3D") {
@@ -433,7 +427,7 @@ void Terrain3D::_update_collision() {
433427
map_data.resize(shape_size * shape_size);
434428

435429
Vector2i region_loc = _storage->get_region_locations()[i];
436-
Vector2i global_loc = region_loc * region_size;
430+
Vector2i global_loc = region_loc * _region_size;
437431
Vector3 global_pos = Vector3(global_loc.x, 0.f, global_loc.y);
438432

439433
Ref<Image> map, map_x, map_z, map_xz;
@@ -446,17 +440,17 @@ void Terrain3D::_update_collision() {
446440
map = region->get_map(TYPE_HEIGHT);
447441
cmap = region->get_map(TYPE_CONTROL);
448442

449-
region = _storage->get_regionp(Vector3(global_pos.x + region_size, 0.f, global_pos.z) * _mesh_vertex_spacing);
443+
region = _storage->get_regionp(Vector3(global_pos.x + _region_size, 0.f, global_pos.z) * _mesh_vertex_spacing);
450444
if (region.is_valid()) {
451445
map_x = region->get_map(TYPE_HEIGHT);
452446
cmap_x = region->get_map(TYPE_CONTROL);
453447
}
454-
region = _storage->get_regionp(Vector3(global_pos.x, 0.f, global_pos.z + region_size) * _mesh_vertex_spacing);
448+
region = _storage->get_regionp(Vector3(global_pos.x, 0.f, global_pos.z + _region_size) * _mesh_vertex_spacing);
455449
if (region.is_valid()) {
456450
map_z = region->get_map(TYPE_HEIGHT);
457451
cmap_z = region->get_map(TYPE_CONTROL);
458452
}
459-
region = _storage->get_regionp(Vector3(global_pos.x + region_size, 0.f, global_pos.z + region_size) * _mesh_vertex_spacing);
453+
region = _storage->get_regionp(Vector3(global_pos.x + _region_size, 0.f, global_pos.z + _region_size) * _mesh_vertex_spacing);
460454
if (region.is_valid()) {
461455
map_xz = region->get_map(TYPE_HEIGHT);
462456
cmap_xz = region->get_map(TYPE_CONTROL);
@@ -472,21 +466,21 @@ void Terrain3D::_update_collision() {
472466
int index = shape_size - 1 - z + x * shape_size;
473467

474468
// Set heights on local map, or adjacent maps if on the last row/col
475-
if (x < region_size && z < region_size) {
469+
if (x < _region_size && z < _region_size) {
476470
map_data[index] = (is_hole(cmap->get_pixel(x, z).r)) ? hole_const : map->get_pixel(x, z).r;
477-
} else if (x == region_size && z < region_size) {
471+
} else if (x == _region_size && z < _region_size) {
478472
if (map_x.is_valid()) {
479473
map_data[index] = (is_hole(cmap_x->get_pixel(0, z).r)) ? hole_const : map_x->get_pixel(0, z).r;
480474
} else {
481475
map_data[index] = 0.0f;
482476
}
483-
} else if (z == region_size && x < region_size) {
477+
} else if (z == _region_size && x < _region_size) {
484478
if (map_z.is_valid()) {
485479
map_data[index] = (is_hole(cmap_z->get_pixel(x, 0).r)) ? hole_const : map_z->get_pixel(x, 0).r;
486480
} else {
487481
map_data[index] = 0.0f;
488482
}
489-
} else if (x == region_size && z == region_size) {
483+
} else if (x == _region_size && z == _region_size) {
490484
if (map_xz.is_valid()) {
491485
map_data[index] = (is_hole(cmap_xz->get_pixel(0, 0).r)) ? hole_const : map_xz->get_pixel(0, 0).r;
492486
} else {
@@ -500,7 +494,7 @@ void Terrain3D::_update_collision() {
500494
//Transform3D xform = Transform3D(Basis(), global_pos);
501495
// Rotated shape Y=90 for -90 rotated array index
502496
Transform3D xform = Transform3D(Basis(Vector3(0.f, 1.f, 0.f), Math_PI * .5f),
503-
global_pos + Vector3(region_size, 0.f, region_size) * .5f);
497+
global_pos + Vector3(_region_size, 0.f, _region_size) * .5f);
504498
xform.scale(Vector3(_mesh_vertex_spacing, 1.f, _mesh_vertex_spacing));
505499

506500
if (!_show_debug_collision) {
@@ -575,7 +569,7 @@ void Terrain3D::_generate_triangles(PackedVector3Array &p_vertices, PackedVector
575569
int32_t step = 1 << CLAMP(p_lod, 0, 8);
576570

577571
if (!p_global_aabb.has_volume()) {
578-
int32_t region_size = (int)_storage->get_region_size();
572+
int32_t region_size = (int32_t)_region_size;
579573

580574
TypedArray<Vector2i> region_locations = _storage->get_region_locations();
581575
for (int r = 0; r < region_locations.size(); ++r) {
@@ -684,6 +678,22 @@ void Terrain3D::set_debug_level(const int p_level) {
684678
debug_level = CLAMP(p_level, 0, DEBUG_MAX);
685679
}
686680

681+
void Terrain3D::set_region_size(const RegionSize p_size) {
682+
LOG(INFO, p_size);
683+
//ERR_FAIL_COND(p_size < SIZE_64);
684+
//ERR_FAIL_COND(p_size > SIZE_2048);
685+
ERR_FAIL_COND(p_size != SIZE_1024);
686+
_region_size = p_size;
687+
// Region size changed, update downstream
688+
if (_storage) {
689+
_storage->_region_size = _region_size;
690+
_storage->_region_sizev = Vector2i(_region_size, _region_size);
691+
}
692+
if (_material.is_valid()) {
693+
_material->_update_maps();
694+
}
695+
}
696+
687697
void Terrain3D::set_mesh_lods(const int p_count) {
688698
if (_mesh_lods != p_count) {
689699
_clear_meshes();
@@ -1117,8 +1127,7 @@ void Terrain3D::update_region_labels() {
11171127
label->set_visibility_range_fade_mode(GeometryInstance3D::VISIBILITY_RANGE_FADE_SELF);
11181128
_label_nodes->add_child(label, true);
11191129
Vector2i loc = region_locations[i];
1120-
int region_size = _storage->get_region_size();
1121-
Vector3 pos = Vector3(real_t(loc.x) + .5f, 0.f, real_t(loc.y) + .5f) * region_size * _mesh_vertex_spacing;
1130+
Vector3 pos = Vector3(real_t(loc.x) + .5f, 0.f, real_t(loc.y) + .5f) * _region_size * _mesh_vertex_spacing;
11221131
label->set_position(pos);
11231132
}
11241133
}
@@ -1345,6 +1354,13 @@ void Terrain3D::_notification(const int p_what) {
13451354
}
13461355

13471356
void Terrain3D::_bind_methods() {
1357+
//BIND_ENUM_CONSTANT(SIZE_64);
1358+
//BIND_ENUM_CONSTANT(SIZE_128);
1359+
//BIND_ENUM_CONSTANT(SIZE_256);
1360+
//BIND_ENUM_CONSTANT(SIZE_512);
1361+
BIND_ENUM_CONSTANT(SIZE_1024);
1362+
//BIND_ENUM_CONSTANT(SIZE_2048);
1363+
13481364
ClassDB::bind_method(D_METHOD("get_version"), &Terrain3D::get_version);
13491365
ClassDB::bind_method(D_METHOD("set_debug_level", "level"), &Terrain3D::set_debug_level);
13501366
ClassDB::bind_method(D_METHOD("get_debug_level"), &Terrain3D::get_debug_level);
@@ -1357,6 +1373,9 @@ void Terrain3D::_bind_methods() {
13571373
ClassDB::bind_method(D_METHOD("set_save_16_bit", "enabled"), &Terrain3D::set_save_16_bit);
13581374
ClassDB::bind_method(D_METHOD("get_save_16_bit"), &Terrain3D::get_save_16_bit);
13591375

1376+
ClassDB::bind_method(D_METHOD("set_region_size", "size"), &Terrain3D::set_region_size);
1377+
ClassDB::bind_method(D_METHOD("get_region_size"), &Terrain3D::get_region_size);
1378+
13601379
ClassDB::bind_method(D_METHOD("set_mesh_lods", "count"), &Terrain3D::set_mesh_lods);
13611380
ClassDB::bind_method(D_METHOD("get_mesh_lods"), &Terrain3D::get_mesh_lods);
13621381
ClassDB::bind_method(D_METHOD("set_mesh_size", "size"), &Terrain3D::set_mesh_size);
@@ -1402,8 +1421,12 @@ void Terrain3D::_bind_methods() {
14021421
ClassDB::bind_method(D_METHOD("bake_mesh", "lod", "filter"), &Terrain3D::bake_mesh);
14031422
ClassDB::bind_method(D_METHOD("generate_nav_mesh_source_geometry", "global_aabb", "require_nav"), &Terrain3D::generate_nav_mesh_source_geometry, DEFVAL(true));
14041423

1424+
int ro_flags = PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_READ_ONLY;
1425+
14051426
ADD_PROPERTY(PropertyInfo(Variant::STRING, "version", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_READ_ONLY), "", "get_version");
14061427
ADD_PROPERTY(PropertyInfo(Variant::STRING, "storage_directory", PROPERTY_HINT_DIR), "set_storage_directory", "get_storage_directory");
1428+
//ADD_PROPERTY(PropertyInfo(Variant::INT, "region_size", PROPERTY_HINT_ENUM, "64:64, 128:128, 256:256, 512:512, 1024:1024, 2048:2048"), "set_region_size", "get_region_size");
1429+
ADD_PROPERTY(PropertyInfo(Variant::INT, "region_size", PROPERTY_HINT_ENUM, "1024:1024"), "set_region_size", "get_region_size");
14071430
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "save_16_bit", PROPERTY_HINT_NONE), "set_save_16_bit", "get_save_16_bit");
14081431
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "Terrain3DMaterial"), "set_material", "get_material");
14091432
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "assets", PROPERTY_HINT_RESOURCE_TYPE, "Terrain3DAssets"), "set_assets", "get_assets");

‎src/terrain_3d.h

+16
Original file line numberDiff line numberDiff line change
@@ -24,12 +24,24 @@ class Terrain3D : public Node3D {
2424
GDCLASS(Terrain3D, Node3D);
2525
CLASS_NAME();
2626

27+
public: // Constants
28+
enum RegionSize {
29+
//SIZE_64 = 64,
30+
//SIZE_128 = 128,
31+
//SIZE_256 = 256,
32+
//SIZE_512 = 512,
33+
SIZE_1024 = 1024,
34+
//SIZE_2048 = 2048,
35+
};
36+
37+
private:
2738
// Terrain state
2839
String _version = "0.9.3-dev";
2940
bool _is_inside_world = false;
3041
bool _initialized = false;
3142

3243
// Terrain settings
44+
RegionSize _region_size = SIZE_1024;
3345
int _mesh_size = 48;
3446
int _mesh_lods = 7;
3547
real_t _mesh_vertex_spacing = 1.0f;
@@ -122,6 +134,8 @@ class Terrain3D : public Node3D {
122134
String get_version() const { return _version; }
123135
void set_debug_level(const int p_level);
124136
int get_debug_level() const { return debug_level; }
137+
void set_region_size(const RegionSize p_size);
138+
RegionSize get_region_size() const { return _region_size; }
125139
void set_mesh_lods(const int p_count);
126140
int get_mesh_lods() const { return _mesh_lods; }
127141
void set_mesh_size(const int p_size);
@@ -200,4 +214,6 @@ class Terrain3D : public Node3D {
200214
static void _bind_methods();
201215
};
202216

217+
VARIANT_ENUM_CAST(Terrain3D::RegionSize);
218+
203219
#endif // TERRAIN3D_CLASS_H

‎src/terrain_3d_editor.cpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@
1414

1515
// Sends the whole region aabb to edited_area
1616
void Terrain3DEditor::_send_region_aabb(const Vector2i &p_region_loc, const Vector2 &p_height_range) {
17-
Terrain3DStorage::RegionSize region_size = _terrain->get_storage()->get_region_size();
17+
Terrain3D::RegionSize region_size = _terrain->get_region_size();
1818
AABB edited_area;
1919
edited_area.position = Vector3(p_region_loc.x * region_size, p_height_range.x, p_region_loc.y * region_size);
2020
edited_area.size = Vector3(region_size, p_height_range.y - p_height_range.x, region_size);
@@ -94,11 +94,11 @@ void Terrain3DEditor::_operate_map(const Vector3 &p_global_position, const real_
9494
return;
9595
}
9696

97-
Terrain3DStorage *storage = _terrain->get_storage();
98-
int region_size = storage->get_region_size();
97+
int region_size = _terrain->get_region_size();
9998
Vector2i region_vsize = Vector2i(region_size, region_size);
10099

101100
// If no region and can't add one, skip whole function. Checked again later
101+
Terrain3DStorage *storage = _terrain->get_storage();
102102
if (!storage->has_regionp(p_global_position) && (!_brush_data["auto_regions"] || _tool != HEIGHT)) {
103103
return;
104104
}

‎src/terrain_3d_instancer.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -482,7 +482,7 @@ void Terrain3DInstancer::update_transforms(const AABB &p_aabb) {
482482
LOG(WARN, "No region found at: ", region_loc);
483483
continue;
484484
}
485-
int region_size = _terrain->get_storage()->get_region_size();
485+
int region_size = _terrain->get_region_size();
486486
Rect2 region_rect;
487487
region_rect.set_position(region_loc * region_size);
488488
region_rect.set_size(Vector2(region_size, region_size));

‎src/terrain_3d_material.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -320,7 +320,7 @@ void Terrain3DMaterial::_update_maps() {
320320
LOG(DEBUG_CONT, "Region_locations size: ", region_locations.size(), " ", region_locations);
321321
RS->material_set_param(_material, "_region_locations", region_locations);
322322

323-
real_t region_size = real_t(storage->get_region_size());
323+
real_t region_size = real_t(_terrain->get_region_size());
324324
LOG(DEBUG_CONT, "Setting region size in material: ", region_size);
325325
RS->material_set_param(_material, "_region_size", region_size);
326326
RS->material_set_param(_material, "_region_texel_size", 1.0f / region_size);

‎src/terrain_3d_storage.cpp

+3-26
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,9 @@ void Terrain3DStorage::initialize(Terrain3D *p_terrain) {
4040
_terrain = p_terrain;
4141
_region_map.resize(REGION_MAP_SIZE * REGION_MAP_SIZE);
4242
_mesh_vertex_spacing = _terrain->get_mesh_vertex_spacing();
43+
_region_size = _terrain->get_region_size();
44+
_region_sizev = Vector2i(_region_size, _region_size);
45+
4346
if (!initialized && !_terrain->get_storage_directory().is_empty()) {
4447
load_directory(_terrain->get_storage_directory());
4548
}
@@ -126,16 +129,6 @@ bool Terrain3DStorage::is_region_deleted(const Vector2i &p_region_loc) const {
126129
return region->is_deleted();
127130
}
128131

129-
void Terrain3DStorage::set_region_size(const RegionSize p_size) {
130-
LOG(INFO, p_size);
131-
//ERR_FAIL_COND(p_size < SIZE_64);
132-
//ERR_FAIL_COND(p_size > SIZE_2048);
133-
ERR_FAIL_COND(p_size != SIZE_1024);
134-
_region_size = p_size;
135-
_region_sizev = Vector2i(_region_size, _region_size);
136-
emit_signal("region_size_changed", _region_size);
137-
}
138-
139132
void Terrain3DStorage::set_region_locations(const TypedArray<Vector2i> &p_locations) {
140133
LOG(INFO, "Setting _region_locations with array sized: ", p_locations.size());
141134
_region_locations = p_locations;
@@ -959,13 +952,6 @@ void Terrain3DStorage::print_audit_data() const {
959952
///////////////////////////
960953

961954
void Terrain3DStorage::_bind_methods() {
962-
//BIND_ENUM_CONSTANT(SIZE_64);
963-
//BIND_ENUM_CONSTANT(SIZE_128);
964-
//BIND_ENUM_CONSTANT(SIZE_256);
965-
//BIND_ENUM_CONSTANT(SIZE_512);
966-
BIND_ENUM_CONSTANT(SIZE_1024);
967-
//BIND_ENUM_CONSTANT(SIZE_2048);
968-
969955
BIND_ENUM_CONSTANT(HEIGHT_FILTER_NEAREST);
970956
BIND_ENUM_CONSTANT(HEIGHT_FILTER_MINIMUM);
971957

@@ -994,10 +980,6 @@ void Terrain3DStorage::_bind_methods() {
994980
ClassDB::bind_method(D_METHOD("get_region_id", "region_location"), &Terrain3DStorage::get_region_id);
995981
ClassDB::bind_method(D_METHOD("get_region_idp", "global_position"), &Terrain3DStorage::get_region_idp);
996982

997-
ClassDB::bind_method(D_METHOD("set_region_size", "size"), &Terrain3DStorage::set_region_size);
998-
ClassDB::bind_method(D_METHOD("get_region_size"), &Terrain3DStorage::get_region_size);
999-
ClassDB::bind_method(D_METHOD("get_region_sizev"), &Terrain3DStorage::get_region_sizev);
1000-
1001983
ClassDB::bind_method(D_METHOD("add_region", "region", "update"), &Terrain3DStorage::add_region, DEFVAL(true));
1002984
ClassDB::bind_method(D_METHOD("add_regionl", "region_location", "update"), &Terrain3DStorage::add_regionl, DEFVAL(true));
1003985
ClassDB::bind_method(D_METHOD("add_regionp", "global_position", "update"), &Terrain3DStorage::add_regionp, DEFVAL(true));
@@ -1048,15 +1030,10 @@ void Terrain3DStorage::_bind_methods() {
10481030
ClassDB::bind_method(D_METHOD("export_image", "file_name", "map_type"), &Terrain3DStorage::export_image);
10491031
ClassDB::bind_method(D_METHOD("layered_to_image", "map_type"), &Terrain3DStorage::layered_to_image);
10501032

1051-
int ro_flags = PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_READ_ONLY;
1052-
//ADD_PROPERTY(PropertyInfo(Variant::INT, "region_size", PROPERTY_HINT_ENUM, "64:64, 128:128, 256:256, 512:512, 1024:1024, 2048:2048"), "set_region_size", "get_region_size");
1053-
ADD_PROPERTY(PropertyInfo(Variant::INT, "region_size", PROPERTY_HINT_ENUM, "1024:1024"), "set_region_size", "get_region_size");
1054-
10551033
ADD_SIGNAL(MethodInfo("maps_changed"));
10561034
ADD_SIGNAL(MethodInfo("region_map_changed"));
10571035
ADD_SIGNAL(MethodInfo("height_maps_changed"));
10581036
ADD_SIGNAL(MethodInfo("control_maps_changed"));
10591037
ADD_SIGNAL(MethodInfo("color_maps_changed"));
1060-
ADD_SIGNAL(MethodInfo("region_size_changed"));
10611038
ADD_SIGNAL(MethodInfo("maps_edited", PropertyInfo(Variant::AABB, "edited_area")));
10621039
}

‎src/terrain_3d_storage.h

+2-18
Original file line numberDiff line numberDiff line change
@@ -21,15 +21,6 @@ class Terrain3DStorage : public Object {
2121
static inline const int REGION_MAP_SIZE = 16;
2222
static inline const Vector2i REGION_MAP_VSIZE = Vector2i(REGION_MAP_SIZE, REGION_MAP_SIZE);
2323

24-
enum RegionSize {
25-
//SIZE_64 = 64,
26-
//SIZE_128 = 128,
27-
//SIZE_256 = 256,
28-
//SIZE_512 = 512,
29-
SIZE_1024 = 1024,
30-
//SIZE_2048 = 2048,
31-
};
32-
3324
enum HeightFilter {
3425
HEIGHT_FILTER_NEAREST,
3526
HEIGHT_FILTER_MINIMUM
@@ -39,6 +30,8 @@ class Terrain3DStorage : public Object {
3930
Terrain3D *_terrain = nullptr;
4031

4132
// Storage Settings & flags
33+
int _region_size = 0;
34+
Vector2i _region_sizev = Vector2i(_region_size, _region_size);
4235
real_t _mesh_vertex_spacing = 1.f; // Set by Terrain3D::set_mesh_vertex_spacing
4336

4437
AABB _edited_area;
@@ -79,10 +72,6 @@ class Terrain3DStorage : public Object {
7972
GeneratedTexture _generated_control_maps;
8073
GeneratedTexture _generated_color_maps;
8174

82-
/// Move to Region?
83-
RegionSize _region_size = SIZE_1024;
84-
Vector2i _region_sizev = Vector2i(_region_size, _region_size);
85-
8675
// Functions
8776
void _clear();
8877

@@ -121,10 +110,6 @@ class Terrain3DStorage : public Object {
121110
int get_region_id(const Vector2i &p_region_loc) const;
122111
int get_region_idp(const Vector3 &p_global_position) const;
123112

124-
void set_region_size(const RegionSize p_size);
125-
RegionSize get_region_size() const { return _region_size; }
126-
Vector2i get_region_sizev() const { return _region_sizev; }
127-
128113
Error add_region(const Ref<Terrain3DRegion> &p_region, const bool p_update = true);
129114
Error add_regionl(const Vector2i &p_region_loc, const Ref<Terrain3DRegion> &p_region, const bool p_update = true);
130115
Error add_regionp(const Vector3 &p_global_position, const Ref<Terrain3DRegion> &p_region, const bool p_update = true);
@@ -192,7 +177,6 @@ class Terrain3DStorage : public Object {
192177
static void _bind_methods();
193178
};
194179

195-
VARIANT_ENUM_CAST(Terrain3DStorage::RegionSize);
196180
VARIANT_ENUM_CAST(Terrain3DStorage::HeightFilter);
197181

198182
/// Inline Region Functions

0 commit comments

Comments
 (0)