Zylann/godot_voxel
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use namespaces in some cpp files that would otherwise be in those namespaces (but aren't because they are registered classes)

Browse Source
This commit is contained in:
Marc Gilleron 2022-01-03 22:01:11 +00:00
parent 492f660831
commit c0cda5d7a7
3 changed files with 121 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
editor/graph/voxel_graph_editor.cpp
View File

@ -20,6 +20,9 @@ const char *VoxelGraphEditor::SIGNAL_NODES_DELETED = "nodes_deleted";
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
using namespace zylann;
using namespace voxel;
// Shows a 2D slice of the 3D set of values coming from an output port
class VoxelGraphEditorNodePreview : public VBoxContainer {
GDCLASS(VoxelGraphEditorNodePreview, VBoxContainer)
@ -214,9 +217,9 @@ VoxelGraphEditor::VoxelGraphEditor() {
add_child(vbox_container);
_context_menu = memnew(PopupMenu);
FixedArray<PopupMenu *, zylann::voxel::VoxelGraphNodeDB::CATEGORY_COUNT> category_menus;
FixedArray<PopupMenu *, VoxelGraphNodeDB::CATEGORY_COUNT> category_menus;
for (unsigned int i = 0; i < category_menus.size(); ++i) {
String name = zylann::voxel::VoxelGraphNodeDB::get_category_name(zylann::voxel::VoxelGraphNodeDB::Category(i));
String name = VoxelGraphNodeDB::get_category_name(VoxelGraphNodeDB::Category(i));
PopupMenu *menu = memnew(PopupMenu);
menu->set_name(name);
menu->connect("id_pressed", callable_mp(this, &VoxelGraphEditor::_on_context_menu_id_pressed));
@ -224,9 +227,8 @@ VoxelGraphEditor::VoxelGraphEditor() {
_context_menu->add_submenu_item(name, name, i);
category_menus[i] = menu;
}
for (int i = 0; i < zylann::voxel::VoxelGraphNodeDB::get_singleton()->get_type_count(); ++i) {
const zylann::voxel::VoxelGraphNodeDB::NodeType &node_type =
zylann::voxel::VoxelGraphNodeDB::get_singleton()->get_type(i);
for (int i = 0; i < VoxelGraphNodeDB::get_singleton()->get_type_count(); ++i) {
const VoxelGraphNodeDB::NodeType &node_type = VoxelGraphNodeDB::get_singleton()->get_type(i);
PopupMenu *menu = category_menus[node_type.category];
menu->add_item(node_type.name, i);
}
@ -346,11 +348,11 @@ void VoxelGraphEditor::build_gui_from_graph() {
// Connections
std::vector<zylann::ProgramGraph::Connection> connections;
std::vector<ProgramGraph::Connection> connections;
graph.get_connections(connections);
for (size_t i = 0; i < connections.size(); ++i) {
const zylann::ProgramGraph::Connection &con = connections[i];
const ProgramGraph::Connection &con = connections[i];
const String from_node_name = node_to_gui_name(con.src.node_id);
const String to_node_name = node_to_gui_name(con.dst.node_id);
VoxelGraphEditorNode *to_node_view = Object::cast_to<VoxelGraphEditorNode>(_graph_edit->get_node(to_node_name));
@ -375,8 +377,7 @@ void VoxelGraphEditor::create_node_gui(uint32_t node_id) {
CRASH_COND(_graph.is_null());
const VoxelGeneratorGraph &graph = **_graph;
const uint32_t node_type_id = graph.get_node_type_id(node_id);
const zylann::voxel::VoxelGraphNodeDB::NodeType &node_type =
zylann::voxel::VoxelGraphNodeDB::get_singleton()->get_type(node_type_id);
const VoxelGraphNodeDB::NodeType &node_type = VoxelGraphNodeDB::get_singleton()->get_type(node_type_id);
const String ui_node_name = node_to_gui_name(node_id);
ERR_FAIL_COND(_graph_edit->has_node(ui_node_name));
@ -395,7 +396,7 @@ void VoxelGraphEditor::create_node_gui(uint32_t node_id) {
// We artificially hide output ports if the node is an output.
// These nodes have an output for implementation reasons, some outputs can process the data like any other node.
const bool hide_outputs = node_type.category == zylann::voxel::VoxelGraphNodeDB::CATEGORY_OUTPUT;
const bool hide_outputs = node_type.category == VoxelGraphNodeDB::CATEGORY_OUTPUT;
const unsigned int row_count = max(node_type.inputs.size(), hide_outputs ? 0 : node_type.outputs.size());
const Color port_color(0.4, 0.4, 1.0);
@ -580,7 +581,7 @@ void VoxelGraphEditor::_on_graph_edit_delete_nodes_request() {
_undo_redo->create_action(TTR("Delete Nodes"));
std::vector<zylann::ProgramGraph::Connection> connections;
std::vector<ProgramGraph::Connection> connections;
_graph->get_connections(connections);
for (size_t i = 0; i < to_erase.size(); ++i) {
@ -595,8 +596,7 @@ void VoxelGraphEditor::_on_graph_edit_delete_nodes_request() {
*_graph, "create_node", node_type_id, _graph->get_node_gui_position(node_id), node_id);
// Params undo
const size_t param_count =
zylann::voxel::VoxelGraphNodeDB::get_singleton()->get_type(node_type_id).params.size();
const size_t param_count = VoxelGraphNodeDB::get_singleton()->get_type(node_type_id).params.size();
for (size_t j = 0; j < param_count; ++j) {
Variant param_value = _graph->get_node_param(node_id, j);
_undo_redo->add_undo_method(*_graph, "set_node_param", node_id, SIZE_T_TO_VARIANT(j), param_value);
@ -606,7 +606,7 @@ void VoxelGraphEditor::_on_graph_edit_delete_nodes_request() {
// Connections undo
for (size_t j = 0; j < connections.size(); ++j) {
const zylann::ProgramGraph::Connection &con = connections[j];
const ProgramGraph::Connection &con = connections[j];
if (con.src.node_id == node_id || con.dst.node_id == node_id) {
_undo_redo->add_undo_method(*_graph, "add_connection", con.src.node_id, con.src.port_index,
@ -711,7 +711,7 @@ void VoxelGraphEditor::update_previews() {
uint64_t time_before = Time::get_singleton()->get_ticks_usec();
const zylann::voxel::VoxelGraphRuntime::CompilationResult result = _graph->compile();
const VoxelGraphRuntime::CompilationResult result = _graph->compile();
if (!result.success) {
ERR_PRINT(String("Voxel graph compilation failed: {0}").format(varray(result.message)));
@ -756,7 +756,7 @@ void VoxelGraphEditor::update_range_analysis_previews() {
_graph->debug_analyze_range(
Vector3iUtil::from_floored(aabb.position), Vector3iUtil::from_floored(aabb.position + aabb.size), true);
const zylann::voxel::VoxelGraphRuntime::State &state = _graph->get_last_state_from_current_thread();
const VoxelGraphRuntime::State &state = _graph->get_last_state_from_current_thread();
const Color greyed_out_color(1, 1, 1, 0.5);
@ -775,7 +775,7 @@ void VoxelGraphEditor::update_range_analysis_previews() {
node_view->set_modulate(greyed_out_color);
for (int port_index = 0; port_index < node_view->output_labels.size(); ++port_index) {
zylann::ProgramGraph::PortLocation loc;
ProgramGraph::PortLocation loc;
loc.node_id = node_view->node_id;
loc.port_index = port_index;
uint32_t address;
@ -834,10 +834,10 @@ void VoxelGraphEditor::update_slice_previews() {
if (node == nullptr || node->preview == nullptr) {
continue;
}
zylann::ProgramGraph::PortLocation dst;
ProgramGraph::PortLocation dst;
dst.node_id = node->node_id;
dst.port_index = 0;
zylann::ProgramGraph::PortLocation src;
ProgramGraph::PortLocation src;
if (!_graph->try_get_connection_to(dst, src)) {
// Not connected?
continue;
@ -884,13 +884,12 @@ void VoxelGraphEditor::update_slice_previews() {
_graph->generate_set(Span<float>(x_vec, 0, x_vec.size()), Span<float>(y_vec, 0, y_vec.size()),
Span<float>(z_vec, 0, z_vec.size()));
const zylann::voxel::VoxelGraphRuntime::State &last_state =
VoxelGeneratorGraph::get_last_state_from_current_thread();
const VoxelGraphRuntime::State &last_state = VoxelGeneratorGraph::get_last_state_from_current_thread();
for (size_t preview_index = 0; preview_index < previews.size(); ++preview_index) {
PreviewInfo &info = previews[preview_index];
const zylann::voxel::VoxelGraphRuntime::Buffer &buffer = last_state.get_buffer(info.address);
const VoxelGraphRuntime::Buffer &buffer = last_state.get_buffer(info.address);
Image &im = **info.control->get_image();
ERR_FAIL_COND(im.get_width() * im.get_height() != static_cast<int>(buffer.size));
@ -934,7 +933,7 @@ void VoxelGraphEditor::_on_graph_node_name_changed(int node_id) {
StringName node_name = _graph->get_node_name(node_id);
const uint32_t node_type_id = _graph->get_node_type_id(node_id);
String node_type_name = zylann::voxel::VoxelGraphNodeDB::get_singleton()->get_type(node_type_id).name;
String node_type_name = VoxelGraphNodeDB::get_singleton()->get_type(node_type_id).name;
const String ui_node_name = node_to_gui_name(node_id);
VoxelGraphEditorNode *node_view = Object::cast_to<VoxelGraphEditorNode>(_graph_edit->get_node(ui_node_name));

14
editor/graph/voxel_graph_node_inspector_wrapper.cpp
View File

@ -3,6 +3,9 @@
#include "../../util/macros.h"
#include <core/object/undo_redo.h>
using namespace zylann;
using namespace voxel;
void VoxelGraphNodeInspectorWrapper::setup(Ref<VoxelGeneratorGraph> p_graph, uint32_t p_node_id, UndoRedo *ur) {
_graph = p_graph;
_node_id = p_node_id;
@ -24,15 +27,14 @@ void VoxelGraphNodeInspectorWrapper::_get_property_list(List<PropertyInfo> *p_li
p_list->push_back(PropertyInfo(Variant::STRING_NAME, "name", PROPERTY_HINT_NONE, String(), PROPERTY_USAGE_EDITOR));
const uint32_t node_type_id = graph->get_node_type_id(_node_id);
const zylann::voxel::VoxelGraphNodeDB::NodeType &node_type =
zylann::voxel::VoxelGraphNodeDB::get_singleton()->get_type(node_type_id);
const VoxelGraphNodeDB::NodeType &node_type = VoxelGraphNodeDB::get_singleton()->get_type(node_type_id);
// Params
p_list->push_back(PropertyInfo(Variant::NIL, "Params", PROPERTY_HINT_NONE, String(), PROPERTY_USAGE_CATEGORY));
for (size_t i = 0; i < node_type.params.size(); ++i) {
const zylann::voxel::VoxelGraphNodeDB::Param &param = node_type.params[i];
const VoxelGraphNodeDB::Param &param = node_type.params[i];
PropertyInfo pi;
pi.name = param.name;
pi.type = param.type;
@ -54,7 +56,7 @@ void VoxelGraphNodeInspectorWrapper::_get_property_list(List<PropertyInfo> *p_li
PropertyInfo(Variant::NIL, "Input Defaults", PROPERTY_HINT_NONE, String(), PROPERTY_USAGE_CATEGORY));
for (size_t i = 0; i < node_type.inputs.size(); ++i) {
const zylann::voxel::VoxelGraphNodeDB::Port &port = node_type.inputs[i];
const VoxelGraphNodeDB::Port &port = node_type.inputs[i];
PropertyInfo pi;
pi.name = port.name;
pi.type = port.default_value.get_type();
@ -82,7 +84,7 @@ bool VoxelGraphNodeInspectorWrapper::_set(const StringName &p_name, const Varian
const uint32_t node_type_id = graph->get_node_type_id(_node_id);
const zylann::voxel::VoxelGraphNodeDB *db = zylann::voxel::VoxelGraphNodeDB::get_singleton();
const VoxelGraphNodeDB *db = VoxelGraphNodeDB::get_singleton();
uint32_t index;
if (db->try_get_param_index_from_name(node_type_id, p_name, index)) {
@ -122,7 +124,7 @@ bool VoxelGraphNodeInspectorWrapper::_get(const StringName &p_name, Variant &r_r
const uint32_t node_type_id = graph->get_node_type_id(_node_id);
const zylann::voxel::VoxelGraphNodeDB *db = zylann::voxel::VoxelGraphNodeDB::get_singleton();
const VoxelGraphNodeDB *db = VoxelGraphNodeDB::get_singleton();
uint32_t index;
if (db->try_get_param_index_from_name(node_type_id, p_name, index)) {

186
generators/graph/voxel_generator_graph.cpp
View File

@ -6,6 +6,9 @@
#include <core/core_string_names.h>
using namespace zylann;
using namespace voxel;
const char *VoxelGeneratorGraph::SIGNAL_NODE_NAME_CHANGED = "node_name_changed";
thread_local VoxelGeneratorGraph::Cache VoxelGeneratorGraph::_cache;
@ -25,12 +28,11 @@ void VoxelGeneratorGraph::clear() {
}
}
static zylann::ProgramGraph::Node *create_node_internal(
zylann::ProgramGraph &graph, VoxelGeneratorGraph::NodeTypeID type_id, Vector2 position, uint32_t id) {
const zylann::voxel::VoxelGraphNodeDB::NodeType &type =
zylann::voxel::VoxelGraphNodeDB::get_singleton()->get_type(type_id);
static ProgramGraph::Node *create_node_internal(
ProgramGraph &graph, VoxelGeneratorGraph::NodeTypeID type_id, Vector2 position, uint32_t id) {
const VoxelGraphNodeDB::NodeType &type = VoxelGraphNodeDB::get_singleton()->get_type(type_id);
zylann::ProgramGraph::Node *node = graph.create_node(type_id, id);
ProgramGraph::Node *node = graph.create_node(type_id, id);
ERR_FAIL_COND_V(node == nullptr, nullptr);
node->inputs.resize(type.inputs.size());
node->outputs.resize(type.outputs.size());
@ -49,15 +51,14 @@ static zylann::ProgramGraph::Node *create_node_internal(
}
uint32_t VoxelGeneratorGraph::create_node(NodeTypeID type_id, Vector2 position, uint32_t id) {
ERR_FAIL_COND_V(!zylann::voxel::VoxelGraphNodeDB::get_singleton()->is_valid_type_id(type_id),
zylann::ProgramGraph::NULL_ID);
const zylann::ProgramGraph::Node *node = create_node_internal(_graph, type_id, position, id);
ERR_FAIL_COND_V(node == nullptr, zylann::ProgramGraph::NULL_ID);
ERR_FAIL_COND_V(!VoxelGraphNodeDB::get_singleton()->is_valid_type_id(type_id), ProgramGraph::NULL_ID);
const ProgramGraph::Node *node = create_node_internal(_graph, type_id, position, id);
ERR_FAIL_COND_V(node == nullptr, ProgramGraph::NULL_ID);
return node->id;
}
void VoxelGeneratorGraph::remove_node(uint32_t node_id) {
zylann::ProgramGraph::Node *node = _graph.try_get_node(node_id);
ProgramGraph::Node *node = _graph.try_get_node(node_id);
ERR_FAIL_COND(node == nullptr);
for (size_t i = 0; i < node->params.size(); ++i) {
Ref<Resource> resource = node->params[i];
@ -71,8 +72,8 @@ void VoxelGeneratorGraph::remove_node(uint32_t node_id) {
bool VoxelGeneratorGraph::can_connect(
uint32_t src_node_id, uint32_t src_port_index, uint32_t dst_node_id, uint32_t dst_port_index) const {
const zylann::ProgramGraph::PortLocation src_port{ src_node_id, src_port_index };
const zylann::ProgramGraph::PortLocation dst_port{ dst_node_id, dst_port_index };
const ProgramGraph::PortLocation src_port{ src_node_id, src_port_index };
const ProgramGraph::PortLocation dst_port{ dst_node_id, dst_port_index };
ERR_FAIL_COND_V(!_graph.is_output_port_valid(src_port), false);
ERR_FAIL_COND_V(!_graph.is_input_port_valid(dst_port), false);
return _graph.can_connect(src_port, dst_port);
@ -80,8 +81,8 @@ bool VoxelGeneratorGraph::can_connect(
void VoxelGeneratorGraph::add_connection(
uint32_t src_node_id, uint32_t src_port_index, uint32_t dst_node_id, uint32_t dst_port_index) {
const zylann::ProgramGraph::PortLocation src_port{ src_node_id, src_port_index };
const zylann::ProgramGraph::PortLocation dst_port{ dst_node_id, dst_port_index };
const ProgramGraph::PortLocation src_port{ src_node_id, src_port_index };
const ProgramGraph::PortLocation dst_port{ dst_node_id, dst_port_index };
ERR_FAIL_COND(!_graph.is_output_port_valid(src_port));
ERR_FAIL_COND(!_graph.is_input_port_valid(dst_port));
_graph.connect(src_port, dst_port);
@ -90,24 +91,24 @@ void VoxelGeneratorGraph::add_connection(
void VoxelGeneratorGraph::remove_connection(
uint32_t src_node_id, uint32_t src_port_index, uint32_t dst_node_id, uint32_t dst_port_index) {
const zylann::ProgramGraph::PortLocation src_port{ src_node_id, src_port_index };
const zylann::ProgramGraph::PortLocation dst_port{ dst_node_id, dst_port_index };
const ProgramGraph::PortLocation src_port{ src_node_id, src_port_index };
const ProgramGraph::PortLocation dst_port{ dst_node_id, dst_port_index };
ERR_FAIL_COND(!_graph.is_output_port_valid(src_port));
ERR_FAIL_COND(!_graph.is_input_port_valid(dst_port));
_graph.disconnect(src_port, dst_port);
emit_changed();
}
void VoxelGeneratorGraph::get_connections(std::vector<zylann::ProgramGraph::Connection> &connections) const {
void VoxelGeneratorGraph::get_connections(std::vector<ProgramGraph::Connection> &connections) const {
_graph.get_connections(connections);
}
bool VoxelGeneratorGraph::try_get_connection_to(
zylann::ProgramGraph::PortLocation dst, zylann::ProgramGraph::PortLocation &out_src) const {
const zylann::ProgramGraph::Node *node = _graph.get_node(dst.node_id);
ProgramGraph::PortLocation dst, ProgramGraph::PortLocation &out_src) const {
const ProgramGraph::Node *node = _graph.get_node(dst.node_id);
CRASH_COND(node == nullptr);
CRASH_COND(dst.port_index >= node->inputs.size());
const zylann::ProgramGraph::Port &port = node->inputs[dst.port_index];
const ProgramGraph::Port &port = node->inputs[dst.port_index];
if (port.connections.size() == 0) {
return false;
}
@ -120,14 +121,14 @@ bool VoxelGeneratorGraph::has_node(uint32_t node_id) const {
}
void VoxelGeneratorGraph::set_node_name(uint32_t node_id, StringName name) {
zylann::ProgramGraph::Node *node = _graph.try_get_node(node_id);
ProgramGraph::Node *node = _graph.try_get_node(node_id);
ERR_FAIL_COND_MSG(node == nullptr, "No node was found with the specified ID");
if (node->name == name) {
return;
}
if (name != StringName()) {
const uint32_t existing_node_id = _graph.find_node_by_name(name);
if (existing_node_id != zylann::ProgramGraph::NULL_ID && node_id == existing_node_id) {
if (existing_node_id != ProgramGraph::NULL_ID && node_id == existing_node_id) {
ERR_PRINT(String("More than one graph node has the name \"{0}\"").format(varray(name)));
}
}
@ -136,7 +137,7 @@ void VoxelGeneratorGraph::set_node_name(uint32_t node_id, StringName name) {
}
StringName VoxelGeneratorGraph::get_node_name(uint32_t node_id) const {
zylann::ProgramGraph::Node *node = _graph.try_get_node(node_id);
ProgramGraph::Node *node = _graph.try_get_node(node_id);
ERR_FAIL_COND_V(node == nullptr, StringName());
return node->name;
}
@ -146,7 +147,7 @@ uint32_t VoxelGeneratorGraph::find_node_by_name(StringName name) const {
}
void VoxelGeneratorGraph::set_node_param(uint32_t node_id, uint32_t param_index, Variant value) {
zylann::ProgramGraph::Node *node = _graph.try_get_node(node_id);
ProgramGraph::Node *node = _graph.try_get_node(node_id);
ERR_FAIL_COND(node == nullptr);
ERR_FAIL_INDEX(param_index, node->params.size());
@ -168,21 +169,21 @@ void VoxelGeneratorGraph::set_node_param(uint32_t node_id, uint32_t param_index,
}
Variant VoxelGeneratorGraph::get_node_param(uint32_t node_id, uint32_t param_index) const {
const zylann::ProgramGraph::Node *node = _graph.try_get_node(node_id);
const ProgramGraph::Node *node = _graph.try_get_node(node_id);
ERR_FAIL_COND_V(node == nullptr, Variant());
ERR_FAIL_INDEX_V(param_index, node->params.size(), Variant());
return node->params[param_index];
}
Variant VoxelGeneratorGraph::get_node_default_input(uint32_t node_id, uint32_t input_index) const {
const zylann::ProgramGraph::Node *node = _graph.try_get_node(node_id);
const ProgramGraph::Node *node = _graph.try_get_node(node_id);
ERR_FAIL_COND_V(node == nullptr, Variant());
ERR_FAIL_INDEX_V(input_index, node->default_inputs.size(), Variant());
return node->default_inputs[input_index];
}
void VoxelGeneratorGraph::set_node_default_input(uint32_t node_id, uint32_t input_index, Variant value) {
zylann::ProgramGraph::Node *node = _graph.try_get_node(node_id);
ProgramGraph::Node *node = _graph.try_get_node(node_id);
ERR_FAIL_COND(node == nullptr);
ERR_FAIL_INDEX(input_index, node->default_inputs.size());
if (node->default_inputs[input_index] != value) {
@ -192,13 +193,13 @@ void VoxelGeneratorGraph::set_node_default_input(uint32_t node_id, uint32_t inpu
}
Vector2 VoxelGeneratorGraph::get_node_gui_position(uint32_t node_id) const {
const zylann::ProgramGraph::Node *node = _graph.try_get_node(node_id);
const ProgramGraph::Node *node = _graph.try_get_node(node_id);
ERR_FAIL_COND_V(node == nullptr, Vector2());
return node->gui_position;
}
void VoxelGeneratorGraph::set_node_gui_position(uint32_t node_id, Vector2 pos) {
zylann::ProgramGraph::Node *node = _graph.try_get_node(node_id);
ProgramGraph::Node *node = _graph.try_get_node(node_id);
ERR_FAIL_COND(node == nullptr);
if (node->gui_position != pos) {
node->gui_position = pos;
@ -206,7 +207,7 @@ void VoxelGeneratorGraph::set_node_gui_position(uint32_t node_id, Vector2 pos) {
}
VoxelGeneratorGraph::NodeTypeID VoxelGeneratorGraph::get_node_type_id(uint32_t node_id) const {
const zylann::ProgramGraph::Node *node = _graph.try_get_node(node_id);
const ProgramGraph::Node *node = _graph.try_get_node(node_id);
ERR_FAIL_COND_V(node == nullptr, NODE_TYPE_COUNT);
CRASH_COND(node->type_id >= NODE_TYPE_COUNT);
return (NodeTypeID)node->type_id;
@ -285,7 +286,7 @@ bool VoxelGeneratorGraph::is_using_xz_caching() const {
// Instead, we could only generate them near zero-crossings, because this is where materials will be seen.
// The problem is that it's harder to manage at the moment, to support edited blocks and LOD...
void VoxelGeneratorGraph::gather_indices_and_weights(Span<const WeightOutput> weight_outputs,
const zylann::voxel::VoxelGraphRuntime::State &state, Vector3i rmin, Vector3i rmax, int ry,
const VoxelGraphRuntime::State &state, Vector3i rmin, Vector3i rmax, int ry,
VoxelBufferInternal &out_voxel_buffer, FixedArray<uint8_t, 4> spare_indices) {
VOXEL_PROFILE_SCOPE();
@ -297,7 +298,7 @@ void VoxelGeneratorGraph::gather_indices_and_weights(Span<const WeightOutput> we
const unsigned int buffers_count = weight_outputs.size();
for (unsigned int oi = 0; oi < buffers_count; ++oi) {
const WeightOutput &info = weight_outputs[oi];
const zylann::voxel::VoxelGraphRuntime::Buffer &buffer = state.get_buffer(info.output_buffer_index);
const VoxelGraphRuntime::Buffer &buffer = state.get_buffer(info.output_buffer_index);
buffers[oi] = Span<const float>(buffer.data, buffer.size);
}
@ -500,7 +501,7 @@ VoxelGenerator::Result VoxelGeneratorGraph::generate_block(VoxelBlockRequest &in
// Slice is on the Y axis
const unsigned int slice_buffer_size = section_size.x * section_size.z;
zylann::voxel::VoxelGraphRuntime &runtime = runtime_ptr->runtime;
VoxelGraphRuntime &runtime = runtime_ptr->runtime;
runtime.prepare_state(cache.state, slice_buffer_size);
cache.x_cache.resize(slice_buffer_size);
@ -582,10 +583,9 @@ VoxelGenerator::Result VoxelGeneratorGraph::generate_block(VoxelBlockRequest &in
_use_optimized_execution_map ? &cache.optimized_execution_map : nullptr);
{
const zylann::voxel::VoxelGraphRuntime::Buffer &sdf_buffer =
const VoxelGraphRuntime::Buffer &sdf_buffer =
cache.state.get_buffer(sdf_output_buffer_index);
zylann::voxel::fill_zx_slice(
sdf_buffer, out_buffer, channel, channel_depth, sdf_scale, rmin, rmax, ry);
fill_zx_slice(sdf_buffer, out_buffer, channel, channel_depth, sdf_scale, rmin, rmax, ry);
}
if (runtime_ptr->weight_outputs_count > 0) {
@ -652,14 +652,14 @@ VoxelGenerator::Result VoxelGeneratorGraph::generate_block(VoxelBlockRequest &in
return result;
}
zylann::voxel::VoxelGraphRuntime::CompilationResult VoxelGeneratorGraph::compile() {
VoxelGraphRuntime::CompilationResult VoxelGeneratorGraph::compile() {
const int64_t time_before = Time::get_singleton()->get_ticks_usec();
std::shared_ptr<Runtime> r = std::make_shared<Runtime>();
zylann::voxel::VoxelGraphRuntime &runtime = r->runtime;
VoxelGraphRuntime &runtime = r->runtime;
// Core compilation
const zylann::voxel::VoxelGraphRuntime::CompilationResult result =
const VoxelGraphRuntime::CompilationResult result =
runtime.compile(_graph, Engine::get_singleton()->is_editor_hint());
if (!result.success) {
@ -668,15 +668,15 @@ zylann::voxel::VoxelGraphRuntime::CompilationResult VoxelGeneratorGraph::compile
// Extra steps
for (unsigned int output_index = 0; output_index < runtime.get_output_count(); ++output_index) {
const zylann::voxel::VoxelGraphRuntime::OutputInfo output = runtime.get_output_info(output_index);
const zylann::ProgramGraph::Node *node = _graph.get_node(output.node_id);
const VoxelGraphRuntime::OutputInfo output = runtime.get_output_info(output_index);
const ProgramGraph::Node *node = _graph.get_node(output.node_id);
ERR_FAIL_COND_V(node == nullptr, zylann::voxel::VoxelGraphRuntime::CompilationResult());
ERR_FAIL_COND_V(node == nullptr, VoxelGraphRuntime::CompilationResult());
switch (node->type_id) {
case NODE_OUTPUT_SDF:
if (r->sdf_output_buffer_index != -1) {
zylann::voxel::VoxelGraphRuntime::CompilationResult error;
VoxelGraphRuntime::CompilationResult error;
error.success = false;
error.message = TTR("Multiple SDF outputs are not supported");
error.node_id = output.node_id;
@ -688,7 +688,7 @@ zylann::voxel::VoxelGraphRuntime::CompilationResult VoxelGeneratorGraph::compile
case NODE_OUTPUT_WEIGHT: {
if (r->weight_outputs_count >= r->weight_outputs.size()) {
zylann::voxel::VoxelGraphRuntime::CompilationResult error;
VoxelGraphRuntime::CompilationResult error;
error.success = false;
error.message = String(TTR("Cannot use more than {0} weight outputs"))
.format(varray(r->weight_outputs.size()));
@ -699,14 +699,14 @@ zylann::voxel::VoxelGraphRuntime::CompilationResult VoxelGeneratorGraph::compile
const int layer_index = node->params[0];
if (layer_index < 0) {
// Should not be allowed by the UI, but who knows
zylann::voxel::VoxelGraphRuntime::CompilationResult error;
VoxelGraphRuntime::CompilationResult error;
error.success = false;
error.message = String(TTR("Cannot use negative layer index in weight output"));
error.node_id = output.node_id;
return error;
}
if (layer_index >= static_cast<int>(r->weight_outputs.size())) {
zylann::voxel::VoxelGraphRuntime::CompilationResult error;
VoxelGraphRuntime::CompilationResult error;
error.success = false;
error.message =
String(TTR("Weight layers cannot exceed {}")).format(varray(r->weight_outputs.size()));
@ -716,7 +716,7 @@ zylann::voxel::VoxelGraphRuntime::CompilationResult VoxelGeneratorGraph::compile
for (unsigned int i = 0; i < r->weight_outputs_count; ++i) {
const WeightOutput &wo = r->weight_outputs[i];
if (static_cast<int>(wo.layer_index) == layer_index) {
zylann::voxel::VoxelGraphRuntime::CompilationResult error;
VoxelGraphRuntime::CompilationResult error;
error.success = false;
error.message =
String(TTR("Only one weight output node can use layer index {0}, found duplicate"))
@ -738,7 +738,7 @@ zylann::voxel::VoxelGraphRuntime::CompilationResult VoxelGeneratorGraph::compile
}
if (r->sdf_output_buffer_index == -1) {
zylann::voxel::VoxelGraphRuntime::CompilationResult error;
VoxelGraphRuntime::CompilationResult error;
error.success = false;
error.message = String(TTR("An SDF output is required for the graph to be valid."));
return error;
@ -772,7 +772,7 @@ zylann::voxel::VoxelGraphRuntime::CompilationResult VoxelGeneratorGraph::compile
}
}
//debug_check_texture_indices(spare_indices);
ERR_FAIL_COND_V(spare_indices_count != 4, zylann::voxel::VoxelGraphRuntime::CompilationResult());
ERR_FAIL_COND_V(spare_indices_count != 4, VoxelGraphRuntime::CompilationResult());
r->spare_texture_indices = spare_indices;
}
@ -796,12 +796,12 @@ void VoxelGeneratorGraph::generate_set(Span<float> in_x, Span<float> in_y, Span<
RWLockRead rlock(_runtime_lock);
ERR_FAIL_COND(_runtime == nullptr);
Cache &cache = _cache;
zylann::voxel::VoxelGraphRuntime &runtime = _runtime->runtime;
VoxelGraphRuntime &runtime = _runtime->runtime;
runtime.prepare_state(cache.state, in_x.size());
runtime.generate_set(cache.state, in_x, in_y, in_z, false, nullptr);
}
const zylann::voxel::VoxelGraphRuntime::State &VoxelGeneratorGraph::get_last_state_from_current_thread() {
const VoxelGraphRuntime::State &VoxelGeneratorGraph::get_last_state_from_current_thread() {
return _cache.state;
}
@ -809,8 +809,7 @@ Span<const int> VoxelGeneratorGraph::get_last_execution_map_debug_from_current_t
return to_span_const(_cache.optimized_execution_map.debug_nodes);
}
bool VoxelGeneratorGraph::try_get_output_port_address(
zylann::ProgramGraph::PortLocation port, uint32_t &out_address) const {
bool VoxelGeneratorGraph::try_get_output_port_address(ProgramGraph::PortLocation port, uint32_t &out_address) const {
RWLockRead rlock(_runtime_lock);
ERR_FAIL_COND_V(_runtime == nullptr, false);
uint16_t addr;
@ -875,16 +874,15 @@ void VoxelGeneratorGraph::bake_sphere_bumpmap(Ref<Image> im, float ref_radius, f
std::vector<float> y_coords;
std::vector<float> z_coords;
Ref<Image> im;
const zylann::voxel::VoxelGraphRuntime &runtime;
zylann::voxel::VoxelGraphRuntime::State &state;
const VoxelGraphRuntime &runtime;
VoxelGraphRuntime::State &state;
const unsigned int sdf_buffer_index;
const float ref_radius;
const float sdf_min;
const float sdf_max;
ProcessChunk(zylann::voxel::VoxelGraphRuntime::State &p_state, unsigned int p_sdf_buffer_index,
const zylann::voxel::VoxelGraphRuntime &p_runtime, float p_ref_radius, float p_sdf_min,
float p_sdf_max) :
ProcessChunk(VoxelGraphRuntime::State &p_state, unsigned int p_sdf_buffer_index,
const VoxelGraphRuntime &p_runtime, float p_ref_radius, float p_sdf_min, float p_sdf_max) :
runtime(p_runtime),
state(p_state),
sdf_buffer_index(p_sdf_buffer_index),
@ -922,7 +920,7 @@ void VoxelGeneratorGraph::bake_sphere_bumpmap(Ref<Image> im, float ref_radius, f
}
runtime.generate_set(state, to_span(x_coords), to_span(y_coords), to_span(z_coords), false, nullptr);
const zylann::voxel::VoxelGraphRuntime::Buffer &buffer = state.get_buffer(sdf_buffer_index);
const VoxelGraphRuntime::Buffer &buffer = state.get_buffer(sdf_buffer_index);
// Calculate final pixels
// TODO Optimize: could convert to buffer directly?
@ -972,13 +970,13 @@ void VoxelGeneratorGraph::bake_sphere_normalmap(Ref<Image> im, float ref_radius,
std::vector<float> sdf_values_py;
unsigned int sdf_buffer_index;
Ref<Image> im;
const zylann::voxel::VoxelGraphRuntime &runtime;
zylann::voxel::VoxelGraphRuntime::State &state;
const VoxelGraphRuntime &runtime;
VoxelGraphRuntime::State &state;
const float strength;
const float ref_radius;
ProcessChunk(zylann::voxel::VoxelGraphRuntime::State &p_state, unsigned int p_sdf_buffer_index, Ref<Image> p_im,
const zylann::voxel::VoxelGraphRuntime &p_runtime, float p_strength, float p_ref_radius) :
ProcessChunk(VoxelGraphRuntime::State &p_state, unsigned int p_sdf_buffer_index, Ref<Image> p_im,
const VoxelGraphRuntime &p_runtime, float p_strength, float p_ref_radius) :
sdf_buffer_index(p_sdf_buffer_index),
im(p_im),
runtime(p_runtime),
@ -1010,7 +1008,7 @@ void VoxelGeneratorGraph::bake_sphere_normalmap(Ref<Image> im, float ref_radius,
const int xmax = x0 + width;
const int ymax = y0 + height;
const zylann::voxel::VoxelGraphRuntime::Buffer &sdf_buffer = state.get_buffer(sdf_buffer_index);
const VoxelGraphRuntime::Buffer &sdf_buffer = state.get_buffer(sdf_buffer_index);
// TODO instead of using 3 separate queries, interleave triplets of positions into a single array?
@ -1113,11 +1111,10 @@ VoxelSingleValue VoxelGeneratorGraph::generate_single(Vector3i position, unsigne
}
ERR_FAIL_COND_V(runtime_ptr == nullptr, v);
Cache &cache = _cache;
const zylann::voxel::VoxelGraphRuntime &runtime = runtime_ptr->runtime;
const VoxelGraphRuntime &runtime = runtime_ptr->runtime;
runtime.prepare_state(cache.state, 1);
runtime.generate_single(cache.state, position, nullptr);
const zylann::voxel::VoxelGraphRuntime::Buffer &buffer =
cache.state.get_buffer(runtime_ptr->sdf_output_buffer_index);
const VoxelGraphRuntime::Buffer &buffer = cache.state.get_buffer(runtime_ptr->sdf_output_buffer_index);
ERR_FAIL_COND_V(buffer.size == 0, v);
ERR_FAIL_COND_V(buffer.data == nullptr, v);
v.f = buffer.data[0];
@ -1135,7 +1132,7 @@ Interval VoxelGeneratorGraph::debug_analyze_range(
}
ERR_FAIL_COND_V(runtime_ptr == nullptr, Interval::from_single_value(0.f));
Cache &cache = _cache;
const zylann::voxel::VoxelGraphRuntime &runtime = runtime_ptr->runtime;
const VoxelGraphRuntime &runtime = runtime_ptr->runtime;
// Note, buffer size is irrelevant here, because range analysis doesn't use buffers
runtime.prepare_state(cache.state, 1);
runtime.analyze_range(cache.state, min_pos, max_pos);
@ -1156,16 +1153,15 @@ Ref<Resource> VoxelGeneratorGraph::duplicate(bool p_subresources) const {
return d;
}
static Dictionary get_graph_as_variant_data(const zylann::ProgramGraph &graph) {
static Dictionary get_graph_as_variant_data(const ProgramGraph &graph) {
Dictionary nodes_data;
graph.for_each_node_id([&graph, &nodes_data](uint32_t node_id) {
const zylann::ProgramGraph::Node *node = graph.get_node(node_id);
const ProgramGraph::Node *node = graph.get_node(node_id);
ERR_FAIL_COND(node == nullptr);
Dictionary node_data;
const zylann::voxel::VoxelGraphNodeDB::NodeType &type =
zylann::voxel::VoxelGraphNodeDB::get_singleton()->get_type(node->type_id);
const VoxelGraphNodeDB::NodeType &type = VoxelGraphNodeDB::get_singleton()->get_type(node->type_id);
node_data["type"] = type.name;
node_data["gui_position"] = node->gui_position;
@ -1174,13 +1170,13 @@ static Dictionary get_graph_as_variant_data(const zylann::ProgramGraph &graph) {
}
for (size_t j = 0; j < type.params.size(); ++j) {
const zylann::voxel::VoxelGraphNodeDB::Param &param = type.params[j];
const VoxelGraphNodeDB::Param &param = type.params[j];
node_data[param.name] = node->params[j];
}
for (size_t j = 0; j < type.inputs.size(); ++j) {
if (node->inputs[j].connections.size() == 0) {
const zylann::voxel::VoxelGraphNodeDB::Port &port = type.inputs[j];
const VoxelGraphNodeDB::Port &port = type.inputs[j];
node_data[port.name] = node->default_inputs[j];
}
}
@ -1190,11 +1186,11 @@ static Dictionary get_graph_as_variant_data(const zylann::ProgramGraph &graph) {
});
Array connections_data;
std::vector<zylann::ProgramGraph::Connection> connections;
std::vector<ProgramGraph::Connection> connections;
graph.get_connections(connections);
connections_data.resize(connections.size());
for (size_t i = 0; i < connections.size(); ++i) {
const zylann::ProgramGraph::Connection &con = connections[i];
const ProgramGraph::Connection &con = connections[i];
Array con_data;
con_data.resize(4);
con_data[0] = con.src.node_id;
@ -1222,17 +1218,17 @@ static bool var_to_id(Variant v, uint32_t &out_id, uint32_t min = 0) {
return true;
}
static bool load_graph_from_variant_data(zylann::ProgramGraph &graph, Dictionary data) {
static bool load_graph_from_variant_data(ProgramGraph &graph, Dictionary data) {
Dictionary nodes_data = data["nodes"];
Array connections_data = data["connections"];
const zylann::voxel::VoxelGraphNodeDB &type_db = *zylann::voxel::VoxelGraphNodeDB::get_singleton();
const VoxelGraphNodeDB &type_db = *VoxelGraphNodeDB::get_singleton();
const Variant *id_key = nullptr;
while ((id_key = nodes_data.next(id_key))) {
const String id_str = *id_key;
ERR_FAIL_COND_V(!id_str.is_valid_int(), false);
const int sid = id_str.to_int();
ERR_FAIL_COND_V(sid < static_cast<int>(zylann::ProgramGraph::NULL_ID), false);
ERR_FAIL_COND_V(sid < static_cast<int>(ProgramGraph::NULL_ID), false);
const uint32_t id = sid;
Dictionary node_data = nodes_data[*id_key];
@ -1241,7 +1237,7 @@ static bool load_graph_from_variant_data(zylann::ProgramGraph &graph, Dictionary
const Vector2 gui_position = node_data["gui_position"];
VoxelGeneratorGraph::NodeTypeID type_id;
ERR_FAIL_COND_V(!type_db.try_get_type_id_from_name(type_name, type_id), false);
zylann::ProgramGraph::Node *node = create_node_internal(graph, type_id, gui_position, id);
ProgramGraph::Node *node = create_node_internal(graph, type_id, gui_position, id);
ERR_FAIL_COND_V(node == nullptr, false);
const Variant *param_key = nullptr;
@ -1270,11 +1266,11 @@ static bool load_graph_from_variant_data(zylann::ProgramGraph &graph, Dictionary
for (int i = 0; i < connections_data.size(); ++i) {
Array con_data = connections_data[i];
ERR_FAIL_COND_V(con_data.size() != 4, false);
zylann::ProgramGraph::PortLocation src;
zylann::ProgramGraph::PortLocation dst;
ERR_FAIL_COND_V(!var_to_id(con_data[0], src.node_id, zylann::ProgramGraph::NULL_ID), false);
ProgramGraph::PortLocation src;
ProgramGraph::PortLocation dst;
ERR_FAIL_COND_V(!var_to_id(con_data[0], src.node_id, ProgramGraph::NULL_ID), false);
ERR_FAIL_COND_V(!var_to_id(con_data[1], src.port_index), false);
ERR_FAIL_COND_V(!var_to_id(con_data[2], dst.node_id, zylann::ProgramGraph::NULL_ID), false);
ERR_FAIL_COND_V(!var_to_id(con_data[2], dst.node_id, ProgramGraph::NULL_ID), false);
ERR_FAIL_COND_V(!var_to_id(con_data[3], dst.port_index), false);
graph.connect(src, dst);
}
@ -1309,7 +1305,7 @@ void VoxelGeneratorGraph::unregister_subresource(Resource &resource) {
}
void VoxelGeneratorGraph::register_subresources() {
_graph.for_each_node([this](zylann::ProgramGraph::Node &node) {
_graph.for_each_node([this](ProgramGraph::Node &node) {
for (size_t i = 0; i < node.params.size(); ++i) {
Ref<Resource> resource = node.params[i];
if (resource.is_valid()) {
@ -1320,7 +1316,7 @@ void VoxelGeneratorGraph::register_subresources() {
}
void VoxelGeneratorGraph::unregister_subresources() {
_graph.for_each_node([this](zylann::ProgramGraph::Node &node) {
_graph.for_each_node([this](ProgramGraph::Node &node) {
for (size_t i = 0; i < node.params.size(); ++i) {
Ref<Resource> resource = node.params[i];
if (resource.is_valid()) {
@ -1339,14 +1335,14 @@ float VoxelGeneratorGraph::debug_measure_microseconds_per_voxel(bool singular) {
runtime_ptr = _runtime;
}
ERR_FAIL_COND_V(runtime_ptr == nullptr, 0.f);
const zylann::voxel::VoxelGraphRuntime &runtime = runtime_ptr->runtime;
const VoxelGraphRuntime &runtime = runtime_ptr->runtime;
const uint32_t cube_size = 16;
const uint32_t cube_count = 250;
// const uint32_t cube_size = 100;
// const uint32_t cube_count = 1;
const uint32_t voxel_count = cube_size * cube_size * cube_size * cube_count;
zylann::ProfilingClock profiling_clock;
ProfilingClock profiling_clock;
uint64_t elapsed_us = 0;
Cache &cache = _cache;
@ -1470,22 +1466,22 @@ void VoxelGeneratorGraph::debug_load_waves_preset() {
// Binding land
int VoxelGeneratorGraph::_b_get_node_type_count() const {
return zylann::voxel::VoxelGraphNodeDB::get_singleton()->get_type_count();
return VoxelGraphNodeDB::get_singleton()->get_type_count();
}
Dictionary VoxelGeneratorGraph::_b_get_node_type_info(int type_id) const {
ERR_FAIL_COND_V(!zylann::voxel::VoxelGraphNodeDB::get_singleton()->is_valid_type_id(type_id), Dictionary());
return zylann::voxel::VoxelGraphNodeDB::get_singleton()->get_type_info_dict(type_id);
ERR_FAIL_COND_V(!VoxelGraphNodeDB::get_singleton()->is_valid_type_id(type_id), Dictionary());
return VoxelGraphNodeDB::get_singleton()->get_type_info_dict(type_id);
}
Array VoxelGeneratorGraph::_b_get_connections() const {
Array con_array;
std::vector<zylann::ProgramGraph::Connection> cons;
std::vector<ProgramGraph::Connection> cons;
_graph.get_connections(cons);
con_array.resize(cons.size());
for (size_t i = 0; i < cons.size(); ++i) {
const zylann::ProgramGraph::Connection &con = cons[i];
const ProgramGraph::Connection &con = cons[i];
Dictionary d;
d["src_node_id"] = con.src.node_id;
d["src_port_index"] = con.src.port_index;
@ -1515,7 +1511,7 @@ Vector2 VoxelGeneratorGraph::_b_debug_analyze_range(Vector3 min_pos, Vector3 max
}
Dictionary VoxelGeneratorGraph::_b_compile() {
zylann::voxel::VoxelGraphRuntime::CompilationResult res = compile();
VoxelGraphRuntime::CompilationResult res = compile();
Dictionary d;
d["success"] = res.success;
if (!res.success) {
@ -1532,7 +1528,7 @@ void VoxelGeneratorGraph::_on_subresource_changed() {
void VoxelGeneratorGraph::_bind_methods() {
ClassDB::bind_method(D_METHOD("clear"), &VoxelGeneratorGraph::clear);
ClassDB::bind_method(D_METHOD("create_node", "type_id", "position", "id"), &VoxelGeneratorGraph::create_node,
DEFVAL(zylann::ProgramGraph::NULL_ID));
DEFVAL(ProgramGraph::NULL_ID));
ClassDB::bind_method(D_METHOD("remove_node", "node_id"), &VoxelGeneratorGraph::remove_node);
ClassDB::bind_method(D_METHOD("can_connect", "src_node_id", "src_port_index", "dst_node_id", "dst_port_index"),
&VoxelGeneratorGraph::can_connect);