okooooooo/EVEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d209097ecf82a8ecd73cc952b4faf4982f3fcd9f
EVEngine/src/modules/procgen/PointGraph.cpp
T

975 lines
44 KiB
C++
Raw Blame History

#include "procgen/PointGraph.h"
#include "procgen/Biome.h"
#include "procgen/PointCompute.h"
#include "procgen/ShapeGrammar.h"
#include <algorithm>
#include <chrono>
#include <cmath>
#include <limits>
#include <sstream>
namespace eve::procgen {
namespace {
struct OperationParam {
const char* key;
const char* kind;
const char* defaultValue;
};
struct OperationSpec {
const char* id;
int inputs;
std::vector<OperationParam> params;
};
const std::vector<OperationSpec>& operationSpecs() {
static const std::vector<OperationSpec> value = {
{"input", 0, {}},
{"spatial.sample", 0, {{"spacing", "float", "1"}, {"seed", "int", "1"}, {"jitter", "float", "0"}}},
{"spatial.filter", 1, {{"invert", "bool", "false"}}},
{"spatial.project", 1, {}},
{"biome.generate", 0, {{"spacing", "float", "1"}, {"seed", "int", "1"},
{"jitter", "float", "0"}}},
{"grammar.generate", 1, {{"grammar", "string", ""}, {"seed", "int", "1"},
{"acceptIncomplete", "bool", "true"}}},
{"merge", 2, {}},
{"copy.points", 2, {{"maxPoints", "int", "100000"},
{"inheritTargetAttributes", "bool", "true"}}},
{"density.remap", 1, {{"inputMin", "float", "0"}, {"inputMax", "float", "1"},
{"outputMin", "float", "0"}, {"outputMax", "float", "1"},
{"clamp", "bool", "true"}}},
{"attribute.math.float", 1, {{"attribute", "string", ""},
{"outputAttribute", "string", ""},
{"operation", "string", "multiply"},
{"operand", "float", "1"},
{"defaultValue", "float", "0"}}},
{"transform", 1, {{"x", "float", "0"}, {"y", "float", "0"}, {"z", "float", "0"},
{"yaw", "float", "0"}, {"scaleX", "float", "1"},
{"scaleY", "float", "1"}, {"scaleZ", "float", "1"}}},
{"filter.float", 1, {{"attribute", "string", ""}, {"min", "float", "0"},
{"max", "float", "1"}, {"invert", "bool", "false"}}},
{"filter.string", 1, {{"attribute", "string", ""}, {"value", "string", ""},
{"invert", "bool", "false"}}},
{"attribute.set.float", 1, {{"attribute", "string", ""}, {"value", "float", "0"}}},
{"attribute.set.string", 1, {{"attribute", "string", ""}, {"value", "string", ""}}},
{"density.cull", 1, {{"seed", "int", "1"}, {"multiplier", "float", "1"}}},
{"self.prune", 1, {{"radius", "float", "1"}}},
{"jitter", 1, {{"seed", "int", "1"}, {"x", "float", "0"}, {"z", "float", "0"}}},
{"branch", 2, {{"condition", "bool", "false"}}},
{"subgraph", 1, {}},
};
return value;
}
bool operationKnown(const std::string& operation) {
const auto& values = operationSpecs();
return std::any_of(values.begin(), values.end(),
[&](const OperationSpec& value) { return operation == value.id; });
}
const OperationSpec* operationSpec(const std::string& operation) {
const auto& values = operationSpecs();
const auto found = std::find_if(values.begin(), values.end(),
[&](const OperationSpec& value) { return operation == value.id; });
return found == values.end() ? nullptr : &*found;
}
const OperationParam* operationParam(const OperationSpec* spec, const std::string& key) {
if (!spec) return nullptr;
const auto found = std::find_if(spec->params.begin(), spec->params.end(),
[&](const OperationParam& value) { return key == value.key; });
return found == spec->params.end() ? nullptr : &*found;
}
uint64_t nowNanoseconds() {
return uint64_t(std::chrono::duration_cast<std::chrono::nanoseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count());
}
PointGraphNodeMetric makeMetric(const std::string& id, const PointSet& points, float milliseconds, bool cacheHit,
const std::string& backend = "cpu") {
PointGraphNodeMetric metric;
metric.id = id;
metric.outputCount = points.getCount();
metric.milliseconds = milliseconds;
metric.cacheHit = cacheHit;
metric.backend = backend;
if (points.empty()) return metric;
const auto& first = points.points().front();
metric.minX = metric.maxX = first.x;
metric.minY = metric.maxY = first.y;
metric.minZ = metric.maxZ = first.z;
double densitySum = 0.0;
for (const auto& point : points.points()) {
metric.minX = std::min(metric.minX, point.x);
metric.minY = std::min(metric.minY, point.y);
metric.minZ = std::min(metric.minZ, point.z);
metric.maxX = std::max(metric.maxX, point.x);
metric.maxY = std::max(metric.maxY, point.y);
metric.maxZ = std::max(metric.maxZ, point.z);
densitySum += point.density;
}
metric.averageDensity = float(densitySum / double(points.getCount()));
return metric;
}
uint64_t spatialSampleUpperBound(const SpatialData& spatial, float spacing) {
if (!spatial.hasBounds() || spacing <= 0.f) return 0;
const auto axisCount = [spacing](float minimum, float maximum) {
if (maximum <= minimum) return uint64_t(1);
return uint64_t(std::floor(double(maximum - minimum) / double(spacing) + 0.001)) + 1;
};
const uint64_t x = axisCount(spatial.getMinX(), spatial.getMaxX());
const uint64_t y = spatial.getKind() == "surface.heightfield"
? uint64_t(1)
: axisCount(spatial.getMinY(), spatial.getMaxY());
const uint64_t z = axisCount(spatial.getMinZ(), spatial.getMaxZ());
const uint64_t maximum = std::numeric_limits<uint64_t>::max();
if (x > maximum / y) return maximum;
const uint64_t xy = x * y;
return xy > maximum / z ? maximum : xy * z;
}
} // namespace
PointGraph::PointGraph() : pointCompute_(std::make_shared<PointCompute>()) {}
bool PointGraph::addNode(const std::string& id, const std::string& operation) {
if (id.empty() || !operationKnown(operation) || nodes_.find(id) != nodes_.end()) return false;
nodes_[id].id = id;
nodes_[id].operation = operation;
nodeOrder_.push_back(id);
invalidateFrom(id);
return true;
}
bool PointGraph::removeNode(const std::string& id) {
if (nodes_.find(id) == nodes_.end()) return false;
invalidateFrom(id);
nodes_.erase(id);
nodeOrder_.erase(std::remove(nodeOrder_.begin(), nodeOrder_.end(), id), nodeOrder_.end());
for (auto it = parameterOrder_.begin(); it != parameterOrder_.end();) {
const auto binding = parameters_.find(*it);
if (binding != parameters_.end() && binding->second.nodeId == id) {
floatOverrides_.erase(*it);
intOverrides_.erase(*it);
stringOverrides_.erase(*it);
parameters_.erase(binding);
it = parameterOrder_.erase(it);
} else {
++it;
}
}
for (auto& [otherId, node] : nodes_)
for (auto& input : node.inputs)
if (input == id) input.clear();
return true;
}
bool PointGraph::hasNode(const std::string& id) const { return nodes_.find(id) != nodes_.end(); }
int PointGraph::getNodeCount() const { return int(nodeOrder_.size()); }
std::string PointGraph::getNodeId(int index) const {
return index >= 0 && index < int(nodeOrder_.size()) ? nodeOrder_[size_t(index)] : std::string();
}
std::string PointGraph::getNodeOperation(const std::string& id) const {
const auto found = nodes_.find(id);
return found == nodes_.end() ? std::string() : found->second.operation;
}
bool PointGraph::connect(const std::string& fromId, const std::string& toId, int inputIndex) {
const auto from = nodes_.find(fromId);
const auto to = nodes_.find(toId);
const auto* spec = to == nodes_.end() ? nullptr : operationSpec(to->second.operation);
if (from == nodes_.end() || to == nodes_.end() || !spec || inputIndex < 0 ||
inputIndex >= spec->inputs || fromId == toId)
return false;
to->second.inputs[inputIndex] = fromId;
invalidateFrom(toId);
return true;
}
bool PointGraph::disconnect(const std::string& toId, int inputIndex) {
const auto to = nodes_.find(toId);
if (to == nodes_.end() || inputIndex < 0 || inputIndex > 1 ||
to->second.inputs[inputIndex].empty())
return false;
to->second.inputs[inputIndex].clear();
invalidateFrom(toId);
return true;
}
std::string PointGraph::getInputNode(const std::string& nodeId, int inputIndex) const {
const auto found = nodes_.find(nodeId);
return found != nodes_.end() && inputIndex >= 0 && inputIndex <= 1
? found->second.inputs[inputIndex]
: std::string();
}
bool PointGraph::setNodePoints(const std::string& id, PointSet* points) {
const auto found = nodes_.find(id);
if (found == nodes_.end() || !points) return false;
if (maxNodeOutputPoints_ > 0 && points->getCount() > maxNodeOutputPoints_) {
error_ = "input exceeds node point budget at node: " + id;
return false;
}
found->second.points = *points;
found->second.hasPoints = true;
invalidateFrom(id);
return true;
}
bool PointGraph::setNodeSpatial(const std::string& id, SpatialData* spatial) {
const auto found = nodes_.find(id);
if (found == nodes_.end() || !spatial) return false;
found->second.spatial = std::make_shared<SpatialData>(*spatial);
invalidateFrom(id);
return true;
}
bool PointGraph::setNodeBiomeRules(const std::string& id, BiomeRules* rules) {
const auto found = nodes_.find(id);
if (found == nodes_.end() || found->second.operation != "biome.generate" || !rules)
return false;
found->second.biomeRules = std::make_shared<BiomeRules>(*rules);
invalidateFrom(id);
return true;
}
bool PointGraph::setNodeShapeGrammar(const std::string& id, ShapeGrammar* grammar) {
const auto found = nodes_.find(id);
if (found == nodes_.end() || found->second.operation != "grammar.generate" || !grammar)
return false;
found->second.shapeGrammar = std::make_shared<ShapeGrammar>(*grammar);
invalidateFrom(id);
return true;
}
bool PointGraph::setNodeFloat(const std::string& id, const std::string& key, float value) {
const auto found = nodes_.find(id);
const auto* spec = found == nodes_.end() ? nullptr : operationSpec(found->second.operation);
const auto* parameter = operationParam(spec, key);
if (!parameter || std::string(parameter->kind) != "float") return false;
found->second.floats[key] = value;
invalidateFrom(id);
return true;
}
bool PointGraph::setNodeInt(const std::string& id, const std::string& key, int value) {
const auto found = nodes_.find(id);
const auto* spec = found == nodes_.end() ? nullptr : operationSpec(found->second.operation);
const auto* parameter = operationParam(spec, key);
if (!parameter ||
(std::string(parameter->kind) != "int" && std::string(parameter->kind) != "bool"))
return false;
found->second.ints[key] = value;
invalidateFrom(id);
return true;
}
bool PointGraph::setNodeString(const std::string& id, const std::string& key,
const std::string& value) {
const auto found = nodes_.find(id);
const auto* spec = found == nodes_.end() ? nullptr : operationSpec(found->second.operation);
const auto* parameter = operationParam(spec, key);
if (!parameter || std::string(parameter->kind) != "string") return false;
found->second.strings[key] = value;
invalidateFrom(id);
return true;
}
bool PointGraph::exposeParameter(const std::string& name, const std::string& nodeId,
const std::string& key) {
const auto node = nodes_.find(nodeId);
if (name.empty() || key.empty() || node == nodes_.end() || parameters_.count(name) != 0)
return false;
const OperationSpec* spec = operationSpec(node->second.operation);
if (!spec) return false;
const auto* parameter = operationParam(spec, key);
if (!parameter) return false;
for (const auto& [existingName, binding] : parameters_)
if (binding.nodeId == nodeId && binding.key == key) return false;
parameters_.emplace(name, ParameterBinding{nodeId, key, parameter->kind});
parameterOrder_.push_back(name);
++revision_;
return true;
}
int PointGraph::getParameterCount() const { return int(parameterOrder_.size()); }
std::string PointGraph::getParameterName(int index) const {
return index >= 0 && index < int(parameterOrder_.size()) ? parameterOrder_[size_t(index)]
: std::string();
}
std::string PointGraph::getParameterKind(const std::string& name) const {
const auto found = parameters_.find(name);
return found == parameters_.end() ? std::string() : found->second.kind;
}
bool PointGraph::hasParameterOverride(const std::string& name) const {
return floatOverrides_.count(name) != 0 || intOverrides_.count(name) != 0 ||
stringOverrides_.count(name) != 0;
}
bool PointGraph::setParameterFloat(const std::string& name, float value) {
const auto found = parameters_.find(name);
if (found == parameters_.end() || found->second.kind != "float") return false;
floatOverrides_[name] = value;
invalidateFrom(found->second.nodeId);
return true;
}
bool PointGraph::setParameterInt(const std::string& name, int value) {
const auto found = parameters_.find(name);
if (found == parameters_.end() || (found->second.kind != "int" &&
found->second.kind != "bool"))
return false;
intOverrides_[name] = value;
invalidateFrom(found->second.nodeId);
return true;
}
bool PointGraph::setParameterString(const std::string& name, const std::string& value) {
const auto found = parameters_.find(name);
if (found == parameters_.end() || found->second.kind != "string") return false;
stringOverrides_[name] = value;
invalidateFrom(found->second.nodeId);
return true;
}
float PointGraph::getParameterFloat(const std::string& name, float fallback) const {
const auto found = parameters_.find(name);
if (found == parameters_.end() || found->second.kind != "float") return fallback;
return floatValue(nodes_.at(found->second.nodeId), found->second.key, fallback);
}
int PointGraph::getParameterInt(const std::string& name, int fallback) const {
const auto found = parameters_.find(name);
if (found == parameters_.end() || (found->second.kind != "int" &&
found->second.kind != "bool"))
return fallback;
return intValue(nodes_.at(found->second.nodeId), found->second.key, fallback);
}
std::string PointGraph::getParameterString(const std::string& name,
const std::string& fallback) const {
const auto found = parameters_.find(name);
if (found == parameters_.end() || found->second.kind != "string") return fallback;
return stringValue(nodes_.at(found->second.nodeId), found->second.key, fallback);
}
bool PointGraph::clearParameterOverride(const std::string& name) {
const auto found = parameters_.find(name);
if (found == parameters_.end() || !hasParameterOverride(name)) return false;
floatOverrides_.erase(name);
intOverrides_.erase(name);
stringOverrides_.erase(name);
invalidateFrom(found->second.nodeId);
return true;
}
bool PointGraph::setNodeSubgraph(const std::string& id, PointGraph* graph,
const std::string& inputNode, const std::string& outputNode) {
const auto found = nodes_.find(id);
if (found == nodes_.end() || found->second.operation != "subgraph" || !graph ||
!graph->hasNode(inputNode) || !graph->hasNode(outputNode))
return false;
found->second.subgraph = std::make_shared<PointGraph>(*graph);
found->second.subgraphInput = inputNode;
found->second.subgraphOutput = outputNode;
invalidateFrom(id);
return true;
}
PointSet* PointGraph::execute(const std::string& outputId) {
error_.clear();
metrics_.clear();
cacheHitCount_ = 0;
evaluatedNodes_ = 0;
lastCancelled_ = false;
computeFallbackReason_.clear();
++executionCount_;
if (cancelRequested_) {
error_ = "execution cancelled";
lastCancelled_ = true;
return nullptr;
}
std::unordered_map<std::string, int> states;
const PointSet* result = evaluate(outputId, states);
return result ? new PointSet(*result) : nullptr;
}
void PointGraph::setExecutionNodeBudget(int nodes) { executionNodeBudget_ = std::max(0, nodes); }
int PointGraph::getExecutionNodeBudget() const { return executionNodeBudget_; }
void PointGraph::setMaxNodeOutputPoints(int points) {
const int clamped = std::max(0, points);
if (maxNodeOutputPoints_ == clamped) return;
maxNodeOutputPoints_ = clamped;
clearCache();
}
int PointGraph::getMaxNodeOutputPoints() const { return maxNodeOutputPoints_; }
bool PointGraph::setComputePolicy(const std::string& policy) {
if (policy != "auto" && policy != "gpu" && policy != "cpu") return false;
if (computePolicy_ == policy) return true;
computePolicy_ = policy;
clearCache();
return true;
}
std::string PointGraph::getComputePolicy() const { return computePolicy_; }
void PointGraph::setComputeMinimumPoints(int points) {
const int clamped = std::max(0, points);
if (computeMinimumPoints_ == clamped) return;
computeMinimumPoints_ = clamped;
clearCache();
}
int PointGraph::getComputeMinimumPoints() const { return computeMinimumPoints_; }
void PointGraph::requestCancel() { cancelRequested_ = true; }
void PointGraph::resetCancellation() {
cancelRequested_ = false;
lastCancelled_ = false;
}
bool PointGraph::wasCancelled() const { return lastCancelled_; }
bool PointGraph::validate() {
error_.clear();
std::unordered_map<std::string, int> states;
for (const auto& id : nodeOrder_)
if (!validateNode(id, states)) return false;
return true;
}
std::string PointGraph::getError() const { return error_; }
void PointGraph::clearCache() {
for (auto& [id, node] : nodes_) {
node.cacheValid = false;
node.deferredTransformValid = false;
}
metrics_.clear();
}
int PointGraph::getExecutionCount() const { return executionCount_; }
int PointGraph::getCacheHitCount() const { return cacheHitCount_; }
uint64_t PointGraph::getRevision() const { return revision_; }
int PointGraph::getMetricCount() const { return int(metrics_.size()); }
std::string PointGraph::getMetricNodeId(int index) const {
return index >= 0 && index < int(metrics_.size()) ? metrics_[size_t(index)].id : std::string();
}
int PointGraph::getMetricOutputCount(int index) const {
return index >= 0 && index < int(metrics_.size()) ? metrics_[size_t(index)].outputCount : 0;
}
float PointGraph::getMetricMilliseconds(int index) const {
return index >= 0 && index < int(metrics_.size()) ? metrics_[size_t(index)].milliseconds : 0.f;
}
bool PointGraph::isMetricCacheHit(int index) const {
return index >= 0 && index < int(metrics_.size()) && metrics_[size_t(index)].cacheHit;
}
std::string PointGraph::getMetricBackend(int index) const {
return index >= 0 && index < int(metrics_.size()) ? metrics_[size_t(index)].backend : std::string();
}
std::string PointGraph::getComputeFallbackReason() const { return computeFallbackReason_; }
uint64_t PointGraph::getComputeUploadCount() const { return pointCompute_->getUploadCount(); }
uint64_t PointGraph::getComputeDispatchCount() const { return pointCompute_->getDispatchCount(); }
uint64_t PointGraph::getComputeReadbackCount() const { return pointCompute_->getReadbackCount(); }
uint64_t PointGraph::getComputeBufferReuseCount() const { return pointCompute_->getBufferReuseCount(); }
uint64_t PointGraph::getComputePeakBufferBytes() const { return pointCompute_->getPeakBufferBytes(); }
int PointGraph::getLastFusedTransformCount() const { return pointCompute_->getLastFusedTransformCount(); }
float PointGraph::getMetricMinX(int index) const {
return index >= 0 && index < int(metrics_.size()) ? metrics_[size_t(index)].minX : 0.f;
}
float PointGraph::getMetricMinY(int index) const {
return index >= 0 && index < int(metrics_.size()) ? metrics_[size_t(index)].minY : 0.f;
}
float PointGraph::getMetricMinZ(int index) const {
return index >= 0 && index < int(metrics_.size()) ? metrics_[size_t(index)].minZ : 0.f;
}
float PointGraph::getMetricMaxX(int index) const {
return index >= 0 && index < int(metrics_.size()) ? metrics_[size_t(index)].maxX : 0.f;
}
float PointGraph::getMetricMaxY(int index) const {
return index >= 0 && index < int(metrics_.size()) ? metrics_[size_t(index)].maxY : 0.f;
}
float PointGraph::getMetricMaxZ(int index) const {
return index >= 0 && index < int(metrics_.size()) ? metrics_[size_t(index)].maxZ : 0.f;
}
float PointGraph::getMetricAverageDensity(int index) const {
return index >= 0 && index < int(metrics_.size())
? metrics_[size_t(index)].averageDensity
: 0.f;
}
PointSet* PointGraph::getNodeOutput(const std::string& id) const { return materializeNodeOutput(id); }
PointSet* PointGraph::materializeNodeOutput(const std::string& id) const {
const auto found = nodes_.find(id);
if (found == nodes_.end()) return nullptr;
const Node& node = found->second;
if (node.cacheValid) return new PointSet(node.cache);
if (!node.deferredTransformValid || node.operation != "transform" || node.inputs[0].empty()) return nullptr;
std::unique_ptr<PointSet> input(materializeNodeOutput(node.inputs[0]));
if (!input) return nullptr;
return new PointSet(transformPointSet(*input, floatValue(node, "x", 0.f), floatValue(node, "y", 0.f),
floatValue(node, "z", 0.f), floatValue(node, "yaw", 0.f),
floatValue(node, "scaleX", 1.f), floatValue(node, "scaleY", 1.f),
floatValue(node, "scaleZ", 1.f)));
}
std::string PointGraph::debugReport() const {
std::ostringstream out;
out << "nodes=" << nodes_.size() << " executions=" << executionCount_
<< " cacheHits=" << cacheHitCount_;
for (const auto& metric : metrics_)
out << "\n"
<< metric.id << " count=" << metric.outputCount << " ms=" << metric.milliseconds
<< " backend=" << metric.backend << (metric.cacheHit ? " cached" : "");
if (!error_.empty()) out << "\nerror=" << error_;
return out.str();
}
int PointGraph::getOperationCount() { return int(operationSpecs().size()); }
std::string PointGraph::getOperationId(int index) {
return index >= 0 && index < int(operationSpecs().size())
? operationSpecs()[size_t(index)].id
: std::string();
}
int PointGraph::getOperationInputCount(const std::string& operation) {
const auto* spec = operationSpec(operation);
return spec ? spec->inputs : -1;
}
int PointGraph::getOperationParamCount(const std::string& operation) {
const auto* spec = operationSpec(operation);
return spec ? int(spec->params.size()) : 0;
}
std::string PointGraph::getOperationParamKey(const std::string& operation, int index) {
const auto* spec = operationSpec(operation);
return spec && index >= 0 && index < int(spec->params.size())
? spec->params[size_t(index)].key
: std::string();
}
std::string PointGraph::getOperationParamKind(const std::string& operation, int index) {
const auto* spec = operationSpec(operation);
return spec && index >= 0 && index < int(spec->params.size())
? spec->params[size_t(index)].kind
: std::string();
}
std::string PointGraph::getOperationParamDefault(const std::string& operation, int index) {
const auto* spec = operationSpec(operation);
return spec && index >= 0 && index < int(spec->params.size())
? spec->params[size_t(index)].defaultValue
: std::string();
}
const PointSet* PointGraph::evaluate(const std::string& id,
std::unordered_map<std::string, int>& states) {
const auto found = nodes_.find(id);
if (found == nodes_.end()) {
error_ = "unknown node: " + id;
return nullptr;
}
Node& node = found->second;
if (node.cacheValid) {
++cacheHitCount_;
PointGraphNodeMetric metric = node.cacheMetric;
metric.milliseconds = 0.f;
metric.cacheHit = true;
metrics_.push_back(std::move(metric));
return &node.cache;
}
if (states[id] == 1) {
error_ = "cycle at node: " + id;
return nullptr;
}
if (cancelRequested_) {
error_ = "execution cancelled at node: " + id;
lastCancelled_ = true;
return nullptr;
}
if (node.operation == "transform") {
const PointSet* segment = evaluateTransformSegment(id, states);
if (segment || !error_.empty()) return segment;
}
states[id] = 1;
const uint64_t started = nowNanoseconds();
std::string nodeBackend = "cpu";
const PointSet* first = nullptr;
const PointSet* second = nullptr;
if (!node.inputs[0].empty()) {
first = evaluate(node.inputs[0], states);
if (!first) return nullptr;
}
if (!node.inputs[1].empty()) {
second = evaluate(node.inputs[1], states);
if (!second) return nullptr;
}
if (executionNodeBudget_ > 0 && evaluatedNodes_ >= executionNodeBudget_) {
error_ = "execution node budget exceeded at node: " + id;
lastCancelled_ = true;
return nullptr;
}
++evaluatedNodes_;
if (node.operation == "input") {
if (!node.hasPoints) error_ = "input node has no points: " + id;
else node.cache = node.points;
} else if (node.operation == "spatial.sample") {
const float spacing = floatValue(node, "spacing", 1.f);
if (!node.spatial) error_ = "spatial.sample has no spatial data: " + id;
else if (maxNodeOutputPoints_ > 0 &&
spatialSampleUpperBound(*node.spatial, spacing) > uint64_t(maxNodeOutputPoints_))
error_ = "spatial.sample exceeds node point budget at node: " + id;
else
node.cache = node.spatial->sample(spacing, uint32_t(intValue(node, "seed", 1)),
floatValue(node, "jitter", 0.f));
} else if (node.operation == "spatial.filter") {
if (!first || !node.spatial) error_ = "spatial.filter requires input and spatial data: " + id;
else node.cache = node.spatial->filter(*first, intValue(node, "invert", 0) != 0);
} else if (node.operation == "spatial.project") {
if (!first || !node.spatial) error_ = "spatial.project requires input and spatial data: " + id;
else node.cache = node.spatial->project(*first);
} else if (node.operation == "biome.generate") {
const float spacing = floatValue(node, "spacing", 1.f);
if (!node.spatial || !node.biomeRules)
error_ = "biome.generate requires spatial data and biome rules: " + id;
else if (maxNodeOutputPoints_ > 0 &&
spatialSampleUpperBound(*node.spatial, spacing) > uint64_t(maxNodeOutputPoints_))
error_ = "biome.generate exceeds node point budget at node: " + id;
else {
std::unique_ptr<PointSet> result(node.biomeRules->generate(
node.spatial.get(), spacing, uint32_t(intValue(node, "seed", 1)),
floatValue(node, "jitter", 0.f)));
if (!result)
error_ = "biome.generate failed at " + id + ": " + node.biomeRules->getError();
else
node.cache = *result;
}
} else if (node.operation == "grammar.generate") {
if (!first || !node.shapeGrammar)
error_ = "grammar.generate requires input and shape grammar: " + id;
else {
std::unique_ptr<PointSet> result(node.shapeGrammar->generate(
stringValue(node, "grammar"), const_cast<PointSet*>(first),
uint32_t(intValue(node, "seed", 1)),
intValue(node, "acceptIncomplete", 1) != 0));
if (!result)
error_ = "grammar.generate failed at " + id + ": " +
node.shapeGrammar->getError();
else
node.cache = *result;
}
} else if (node.operation == "merge") {
const uint64_t outputCount = first && second
? uint64_t(first->getCount()) + uint64_t(second->getCount())
: 0;
if (!first || !second) error_ = "merge requires two inputs: " + id;
else if (maxNodeOutputPoints_ > 0 && outputCount > uint64_t(maxNodeOutputPoints_))
error_ = "merge exceeds node point budget at node: " + id;
else node.cache = mergePointSets(*first, *second);
} else if (node.operation == "copy.points") {
const int maxPoints = intValue(node, "maxPoints", 100000);
const uint64_t outputCount = first && second
? uint64_t(first->getCount()) * uint64_t(second->getCount())
: 0;
if (!first || !second) error_ = "copy.points requires source and target inputs: " + id;
else if (maxPoints < 0 || outputCount > uint64_t(maxPoints))
error_ = "copy.points output exceeds maxPoints at node: " + id;
else if (maxNodeOutputPoints_ > 0 && outputCount > uint64_t(maxNodeOutputPoints_))
error_ = "copy.points exceeds node point budget at node: " + id;
else
node.cache = copyPointsToTargets(
*first, *second, intValue(node, "inheritTargetAttributes", 1) != 0);
} else if (node.operation == "density.remap") {
const float inputMin = floatValue(node, "inputMin", 0.f);
const float inputMax = floatValue(node, "inputMax", 1.f);
if (!first) error_ = "density.remap requires input: " + id;
else if (inputMin == inputMax)
error_ = "density.remap requires a non-zero input range: " + id;
else
node.cache = remapPointDensity(
*first, inputMin, inputMax, floatValue(node, "outputMin", 0.f),
floatValue(node, "outputMax", 1.f), intValue(node, "clamp", 1) != 0);
} else if (node.operation == "attribute.math.float") {
const std::string attribute = stringValue(node, "attribute");
std::string outputAttribute = stringValue(node, "outputAttribute");
if (outputAttribute.empty()) outputAttribute = attribute;
const std::string operation = stringValue(node, "operation", "multiply");
const float operand = floatValue(node, "operand", 1.f);
const bool operationKnown = operation == "add" || operation == "subtract" ||
operation == "multiply" || operation == "divide" ||
operation == "min" || operation == "max";
if (!first) error_ = "attribute.math.float requires input: " + id;
else if (attribute.empty()) error_ = "attribute.math.float requires an attribute: " + id;
else if (!operationKnown)
error_ = "attribute.math.float has invalid operation at node: " + id;
else if (operation == "divide" && operand == 0.f)
error_ = "attribute.math.float cannot divide by zero at node: " + id;
else
node.cache = mathPointFloatAttribute(
*first, attribute, outputAttribute, operation, operand,
floatValue(node, "defaultValue", 0.f));
} else if (node.operation == "transform") {
if (!first) error_ = "transform requires input: " + id;
else {
const bool gpuEligible =
!first->empty() &&
(computePolicy_ == "gpu" || (computePolicy_ == "auto" && first->getCount() >= computeMinimumPoints_));
const bool gpuComplete =
gpuEligible &&
pointCompute_->transform(*first, node.cache, floatValue(node, "x", 0.f), floatValue(node, "y", 0.f),
floatValue(node, "z", 0.f), floatValue(node, "yaw", 0.f),
floatValue(node, "scaleX", 1.f), floatValue(node, "scaleY", 1.f),
floatValue(node, "scaleZ", 1.f));
if (gpuComplete) {
#ifdef EVENGINE_WEBGPU
nodeBackend = "webgpu";
#else
nodeBackend = "vulkan";
#endif
} else {
if (gpuEligible) computeFallbackReason_ = pointCompute_->getError();
node.cache = transformPointSet(*first, floatValue(node, "x", 0.f), floatValue(node, "y", 0.f),
floatValue(node, "z", 0.f), floatValue(node, "yaw", 0.f),
floatValue(node, "scaleX", 1.f), floatValue(node, "scaleY", 1.f),
floatValue(node, "scaleZ", 1.f));
}
}
} else if (node.operation == "filter.float") {
if (!first) error_ = "filter.float requires input: " + id;
else
node.cache = filterPointFloatAttribute(
*first, stringValue(node, "attribute"), floatValue(node, "min", 0.f),
floatValue(node, "max", 1.f), intValue(node, "invert", 0) != 0);
} else if (node.operation == "filter.string") {
if (!first) error_ = "filter.string requires input: " + id;
else
node.cache = filterPointStringAttribute(
*first, stringValue(node, "attribute"), stringValue(node, "value"),
intValue(node, "invert", 0) != 0);
} else if (node.operation == "attribute.set.float") {
if (!first) error_ = "attribute.set.float requires input: " + id;
else {
node.cache = *first;
const std::string attribute = stringValue(node, "attribute");
if (attribute.empty()) error_ = "attribute.set.float requires attribute: " + id;
else
for (int i = 0; i < node.cache.getCount(); ++i)
node.cache.setFloatAttribute(i, attribute, floatValue(node, "value", 0.f));
}
} else if (node.operation == "attribute.set.string") {
if (!first) error_ = "attribute.set.string requires input: " + id;
else {
node.cache = *first;
const std::string attribute = stringValue(node, "attribute");
if (attribute.empty()) error_ = "attribute.set.string requires attribute: " + id;
else
for (int i = 0; i < node.cache.getCount(); ++i)
node.cache.setStringAttribute(i, attribute, stringValue(node, "value"));
}
} else if (node.operation == "density.cull") {
if (!first) error_ = "density.cull requires input: " + id;
else
node.cache = densityCullPoints(*first, uint32_t(intValue(node, "seed", 1)),
floatValue(node, "multiplier", 1.f));
} else if (node.operation == "self.prune") {
if (!first) error_ = "self.prune requires input: " + id;
else node.cache = selfPrunePoints(*first, floatValue(node, "radius", 1.f));
} else if (node.operation == "jitter") {
if (!first) error_ = "jitter requires input: " + id;
else
node.cache = jitterPointPositions(*first, uint32_t(intValue(node, "seed", 1)),
floatValue(node, "x", 0.f),
floatValue(node, "z", 0.f));
} else if (node.operation == "branch") {
const bool condition = intValue(node, "condition", 0) != 0;
if ((condition && !first) || (!condition && !second))
error_ = "branch requires both selected inputs: " + id;
else node.cache = condition ? *first : *second;
} else if (node.operation == "subgraph") {
if (!first || !node.subgraph) error_ = "subgraph requires input and graph: " + id;
else {
node.subgraph->setMaxNodeOutputPoints(maxNodeOutputPoints_);
node.subgraph->setComputePolicy(computePolicy_);
node.subgraph->setComputeMinimumPoints(computeMinimumPoints_);
if (!node.subgraph->setNodePoints(node.subgraphInput, const_cast<PointSet*>(first)))
error_ = "subgraph input failed at " + id + ": " + node.subgraph->getError();
else {
std::unique_ptr<PointSet> result(node.subgraph->execute(node.subgraphOutput));
if (!result)
error_ = "subgraph failed at " + id + ": " + node.subgraph->getError();
else
node.cache = *result;
}
}
}
if (error_.empty() && maxNodeOutputPoints_ > 0 &&
node.cache.getCount() > maxNodeOutputPoints_) {
node.cache.clear();
error_ = node.operation + " exceeds node point budget at node: " + id;
}
if (!error_.empty()) return nullptr;
node.cacheValid = true;
states[id] = 2;
const float elapsed = float(nowNanoseconds() - started) * 0.000001f;
node.cacheMetric = makeMetric(id, node.cache, elapsed, false, nodeBackend);
metrics_.push_back(node.cacheMetric);
return &node.cache;
}
const PointSet* PointGraph::evaluateTransformSegment(const std::string& id,
std::unordered_map<std::string, int>& states) {
std::vector<std::string> chain;
std::string cursor = id;
while (chain.size() < 4) {
const auto found = nodes_.find(cursor);
if (found == nodes_.end() || found->second.operation != "transform" || found->second.cacheValid ||
found->second.inputs[0].empty())
break;
chain.push_back(cursor);
cursor = found->second.inputs[0];
}
if (chain.size() < 2) return nullptr;
std::reverse(chain.begin(), chain.end());
const PointSet* input = evaluate(cursor, states);
if (!input) return nullptr;
const bool gpuEligible =
!input->empty() &&
(computePolicy_ == "gpu" || (computePolicy_ == "auto" && input->getCount() >= computeMinimumPoints_));
if (!gpuEligible) return nullptr;
if (executionNodeBudget_ > 0 && evaluatedNodes_ + int(chain.size()) > executionNodeBudget_) {
error_ = "execution node budget exceeded at node: " + id;
lastCancelled_ = true;
return nullptr;
}
std::vector<PointCompute::Transform> transforms;
transforms.reserve(chain.size());
for (const std::string& nodeId : chain) {
const Node& transformNode = nodes_.at(nodeId);
transforms.push_back({floatValue(transformNode, "x", 0.f), floatValue(transformNode, "y", 0.f),
floatValue(transformNode, "z", 0.f), floatValue(transformNode, "yaw", 0.f),
floatValue(transformNode, "scaleX", 1.f), floatValue(transformNode, "scaleY", 1.f),
floatValue(transformNode, "scaleZ", 1.f)});
}
PointSet output;
const uint64_t started = nowNanoseconds();
if (!pointCompute_->transformChain(*input, output, transforms)) {
computeFallbackReason_ = pointCompute_->getError();
return nullptr;
}
evaluatedNodes_ += int(chain.size());
for (const std::string& nodeId : chain) {
Node& transformNode = nodes_.at(nodeId);
transformNode.deferredTransformValid = true;
states[nodeId] = 2;
}
Node& finalNode = nodes_.at(id);
finalNode.cache = std::move(output);
finalNode.cacheValid = true;
finalNode.deferredTransformValid = false;
#ifdef EVENGINE_WEBGPU
const std::string backend = "webgpu";
#else
const std::string backend = "vulkan";
#endif
const float elapsed = float(nowNanoseconds() - started) * 0.000001f;
finalNode.cacheMetric = makeMetric(id, finalNode.cache, elapsed, false, backend);
metrics_.push_back(finalNode.cacheMetric);
return &finalNode.cache;
}
bool PointGraph::validateNode(const std::string& id, std::unordered_map<std::string, int>& states) {
if (states[id] == 2) return true;
if (states[id] == 1) {
error_ = "cycle at node: " + id;
return false;
}
const auto found = nodes_.find(id);
if (found == nodes_.end() || !operationKnown(found->second.operation)) {
error_ = "invalid node: " + id;
return false;
}
states[id] = 1;
for (const auto& input : found->second.inputs) {
if (!input.empty() && !validateNode(input, states)) return false;
}
const auto& node = found->second;
if (node.operation == "input" && !node.hasPoints) error_ = "input node has no points: " + id;
else if ((node.operation == "spatial.sample" || node.operation == "spatial.filter" ||
node.operation == "spatial.project" || node.operation == "biome.generate") &&
!node.spatial)
error_ = "node has no spatial data: " + id;
else if (node.operation == "biome.generate" && !node.biomeRules)
error_ = "node has no biome rules: " + id;
else if (node.operation == "grammar.generate" && !node.shapeGrammar)
error_ = "node has no shape grammar: " + id;
else if (node.operation == "subgraph" && (!node.subgraph || node.inputs[0].empty()))
error_ = "subgraph is not configured: " + id;
else if (node.operation == "subgraph") {
PointGraph nested = *node.subgraph;
PointSet externalInput;
if (!nested.setNodePoints(node.subgraphInput, &externalInput) || !nested.validate())
error_ = "invalid subgraph at " + id + ": " + nested.getError();
} else {
const auto* spec = operationSpec(node.operation);
for (int index = 0; spec && index < spec->inputs; ++index)
if (node.inputs[index].empty()) {
error_ = node.operation + " requires input " + std::to_string(index) + ": " + id;
break;
}
}
if (!error_.empty()) return false;
states[id] = 2;
return true;
}
void PointGraph::invalidate() { clearCache(); }
void PointGraph::invalidateFrom(const std::string& id) {
++revision_;
std::vector<std::string> dirty{id};
std::unordered_map<std::string, bool> visited;
for (size_t cursor = 0; cursor < dirty.size(); ++cursor) {
const std::string current = dirty[cursor];
if (visited[current]) continue;
visited[current] = true;
const auto found = nodes_.find(current);
if (found != nodes_.end()) {
found->second.cacheValid = false;
found->second.deferredTransformValid = false;
}
for (const auto& [candidateId, candidate] : nodes_) {
if (candidate.inputs[0] == current || candidate.inputs[1] == current)
dirty.push_back(candidateId);
}
}
metrics_.clear();
}
float PointGraph::floatValue(const Node& node, const std::string& key, float fallback) const {
for (const auto& name : parameterOrder_) {
const auto& binding = parameters_.at(name);
if (binding.nodeId == node.id && binding.key == key) {
const auto overridden = floatOverrides_.find(name);
if (overridden != floatOverrides_.end()) return overridden->second;
}
}
const auto found = node.floats.find(key);
return found == node.floats.end() ? fallback : found->second;
}
int PointGraph::intValue(const Node& node, const std::string& key, int fallback) const {
for (const auto& name : parameterOrder_) {
const auto& binding = parameters_.at(name);
if (binding.nodeId == node.id && binding.key == key) {
const auto overridden = intOverrides_.find(name);
if (overridden != intOverrides_.end()) return overridden->second;
}
}
const auto found = node.ints.find(key);
return found == node.ints.end() ? fallback : found->second;
}
std::string PointGraph::stringValue(const Node& node, const std::string& key,
const std::string& fallback) const {
for (const auto& name : parameterOrder_) {
const auto& binding = parameters_.at(name);
if (binding.nodeId == node.id && binding.key == key) {
const auto overridden = stringOverrides_.find(name);
if (overridden != stringOverrides_.end()) return overridden->second;
}
}
const auto found = node.strings.find(key);
return found == node.strings.end() ? fallback : found->second;
}
} // namespace eve::procgen
Reference in new issue View Git Blame Copy Permalink