slapin/streaming_world
1
0
Fork 0
Code Issues 32 Pull Requests Packages Projects 2 Releases Wiki Activity

Separated and cleaned interior/exterior stuff

Browse Source
This commit is contained in:
Sergey Lapin
2024-12-06 01:00:03 +03:00
parent b427de968f
commit d46401b973
3 changed files with 71 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/flecs

Submodule src/flecs updated: d4462b4cd0...57ebed1083

2
src/godot

Submodule src/godot updated: 36a01852a7...7fbb30e55b

148
src/modules/stream/ui/setup_3d_viewport.h
View File

@@ -28,12 +28,13 @@ class Setup3DViewport : public Object {
String current_graph;
int current_floor;
BuildingLayoutGraphUI *base;
MeshInstance *display_mi_exterior, *display_mi_interior;
MeshInstance *display_mi[2];
Ref<MeshLibrary> layout_parts;
protected:
void setup()
{
int i;
wc = memnew(ViewportContainer);
view = memnew(Viewport);
light = memnew(DirectionalLight);
@@ -71,10 +72,10 @@ protected:
base_mi->set_mesh(cube);
base_mi->set_translation(Vector3(0, -0.5, 0));
view->call_deferred("add_child", base_mi);
display_mi_exterior = memnew(MeshInstance);
view->call_deferred("add_child", display_mi_exterior);
display_mi_interior = memnew(MeshInstance);
view->call_deferred("add_child", display_mi_interior);
for (i = 0; i < 2; i++) {
display_mi[i] = memnew(MeshInstance);
view->call_deferred("add_child", display_mi[i]);
}
}
void build_mesh_data()
{
@@ -96,32 +97,35 @@ protected:
buildings_layout_grid_cell>()
.with(flecs::ChildOf, grid_floor_e)
.build();
Ref<ArrayMesh> layout_mesh_exterior, layout_mesh_interior;
layout_mesh_exterior.instance();
layout_mesh_interior.instance();
SurfaceTool tool_exterior, tool_interior;
Ref<Material> mat_exterior, mat_interior;
layout_mesh_exterior->set_storage_mode(Mesh::STORAGE_MODE_CPU);
layout_mesh_interior->set_storage_mode(Mesh::STORAGE_MODE_CPU);
tool_exterior.create_from(layout_mesh_exterior, 0);
tool_interior.create_from(layout_mesh_interior, 0);
struct item_set {
Ref<ArrayMesh> layout_mesh;
Vector<Pair<int, Transform> > items;
Ref<Material> mat;
SurfaceTool tool;
item_set()
{
layout_mesh.instance();
layout_mesh->set_storage_mode(
Mesh::STORAGE_MODE_CPU);
tool.create_from(layout_mesh, 0);
}
};
int k;
struct item_set item_data[2];
Transform offset(Basis(), Vector3(-grid_size * 4 / 2, 0,
-grid_size * 4 / 2));
cells_query.each([this, grid_size, offset, &tool_exterior,
&tool_interior, &mat_exterior, &mat_interior](
flecs::entity e,
const WorldEditor::components::
buildings_layout_grid_cell
&cell) {
int i;
cells_query.each([this, grid_size, offset,
&item_data](flecs::entity e,
const WorldEditor::components::
buildings_layout_grid_cell
&cell) {
int i, j;
int x = cell.index % grid_size;
int y = 0;
int z = cell.index / grid_size;
Transform base_transform(Basis(),
Vector3(x * 4, 0, z * 4));
int matches = 0;
Vector<Pair<int, Transform> > items_exterior;
Vector<Pair<int, Transform> > items_interior;
struct pmatch {
int mask;
String item;
@@ -187,6 +191,8 @@ protected:
matches |= 64;
if (e.has<WorldEditor::components::internal_wall_east>())
matches |= 128;
for (i = 0; i < 2; i++)
item_data[i].items.clear();
for (i = 0; i < (int)sizeof(match_data) /
(int)sizeof(match_data[0]);
i++) {
@@ -202,70 +208,54 @@ protected:
item_transform.origin =
match_data[i].offset;
if (match_data[i].exterior)
items_exterior.push_back(
item_data[0].items.push_back(
{ id, item_transform });
else
items_interior.push_back(
item_data[1].items.push_back(
{ id, item_transform });
}
}
for (i = 0; i < items_exterior.size(); i++) {
Ref<Mesh> mesh = layout_parts->get_item_mesh(
items_exterior[i].first);
assert(mesh.is_valid());
if (!mat_exterior.is_valid())
mat_exterior =
mesh->surface_get_material(0);
tool_exterior.append_from(
mesh, 0,
offset * base_transform *
items_exterior[i].second);
}
for (i = 0; i < items_interior.size(); i++) {
Ref<Mesh> mesh = layout_parts->get_item_mesh(
items_interior[i].first);
assert(mesh.is_valid());
if (!mat_interior.is_valid())
mat_interior =
mesh->surface_get_material(0);
tool_interior.append_from(
mesh, 0,
offset * base_transform *
items_interior[i].second);
for (j = 0; j < 2; j++) {
for (i = 0; i < item_data[j].items.size();
i++) {
Ref<Mesh> mesh =
layout_parts->get_item_mesh(
item_data[j]
.items[i]
.first);
assert(mesh.is_valid());
if (!item_data[j].mat.is_valid())
item_data[j].mat =
mesh->surface_get_material(
0);
item_data[j].tool.append_from(
mesh, 0,
offset * base_transform *
item_data[j]
.items[i]
.second);
}
}
});
Array arr_exterior = tool_exterior.commit_to_arrays();
layout_mesh_exterior->add_surface_from_arrays(
Mesh::PRIMITIVE_TRIANGLES, arr_exterior, Array(),
Mesh::ARRAY_COMPRESS_DEFAULT);
if (!mat_exterior.is_valid()) {
Ref<SpatialMaterial> spmat;
spmat.instance();
spmat->set_albedo(Color(1.0f, 0.6f, 0.6f));
mat_exterior = spmat;
for (k = 0; k < 2; k++) {
Array arr = item_data[k].tool.commit_to_arrays();
item_data[k].layout_mesh->add_surface_from_arrays(
Mesh::PRIMITIVE_TRIANGLES, arr, Array(),
Mesh::ARRAY_COMPRESS_DEFAULT);
if (!item_data[k].mat.is_valid()) {
Ref<SpatialMaterial> spmat;
spmat.instance();
spmat->set_albedo(Color(1.0f, 0.6f, 0.6f));
item_data[k].mat = spmat;
}
item_data[k].layout_mesh->surface_set_material(
0, item_data[k].mat);
display_mi[k]->hide();
display_mi[k]->set_mesh(item_data[k].layout_mesh);
item_data[k].layout_mesh->set_storage_mode(
Mesh::STORAGE_MODE_CPU_AND_GPU);
display_mi[k]->show();
}
Array arr_interior = tool_interior.commit_to_arrays();
layout_mesh_interior->add_surface_from_arrays(
Mesh::PRIMITIVE_TRIANGLES, arr_interior, Array(),
Mesh::ARRAY_COMPRESS_DEFAULT);
if (!mat_interior.is_valid()) {
Ref<SpatialMaterial> spmat;
spmat.instance();
spmat->set_albedo(Color(1.0f, 0.6f, 0.6f));
mat_interior = spmat;
}
layout_mesh_exterior->surface_set_material(0, mat_exterior);
display_mi_exterior->hide();
display_mi_exterior->set_mesh(layout_mesh_exterior);
layout_mesh_exterior->set_storage_mode(
Mesh::STORAGE_MODE_CPU_AND_GPU);
display_mi_exterior->show();
layout_mesh_interior->surface_set_material(0, mat_interior);
display_mi_interior->hide();
display_mi_interior->set_mesh(layout_mesh_interior);
layout_mesh_interior->set_storage_mode(
Mesh::STORAGE_MODE_CPU_AND_GPU);
display_mi_interior->show();
}
void resize()
{