okooooooo/EVEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ad38d51c295a8b1b9f95bf1d6f42994de3696f76
EVEngine/test/procgen_point_graph.cpp
T

550 lines
21 KiB
C++
Raw Blame History

#include "procgen/Biome.h"
#include "procgen/PointGraph.h"
#include "procgen/ShapeGrammar.h"
#include <cmath>
#include "zeroerr/assert.h"
#include "zeroerr/unittest.h"
using namespace eve::procgen;
TEST_CASE("procgen.pointGraph.executesDagAndCachesResults") {
PointGraph graph;
CHECK(graph.addNode("sample", "spatial.sample"));
CHECK(graph.addNode("exclude", "spatial.filter"));
CHECK(graph.addNode("prune", "self.prune"));
CHECK(graph.connect("sample", "exclude"));
CHECK(graph.connect("exclude", "prune"));
SpatialData domain = SpatialData::box(0.f, 0.f, 0.f, 4.f, 0.f, 4.f);
SpatialData hole = SpatialData::sphere(2.f, 0.f, 2.f, 0.75f);
CHECK(graph.setNodeSpatial("sample", &domain));
CHECK(graph.setNodeFloat("sample", "spacing", 2.f));
CHECK(graph.setNodeInt("sample", "seed", 42));
CHECK(graph.setNodeSpatial("exclude", &hole));
CHECK(graph.setNodeInt("exclude", "invert", 1));
CHECK(graph.setNodeFloat("prune", "radius", 1.f));
CHECK(graph.validate());
PointSet* first = graph.execute("prune");
REQUIRE(bool(first));
CHECK_EQ(first->getCount(), 8);
CHECK(graph.getMetricCount() >= 3);
PointSet* debug = graph.getNodeOutput("sample");
REQUIRE(bool(debug));
CHECK_EQ(debug->getCount(), 9);
PointSet* second = graph.execute("prune");
REQUIRE(bool(second));
CHECK_EQ(second->getCount(), 8);
CHECK_EQ(graph.getCacheHitCount(), 1);
CHECK(graph.isMetricCacheHit(0));
delete second;
delete debug;
delete first;
}
TEST_CASE("procgen.pointGraph.rejectsCyclesAndBadInputs") {
PointGraph graph;
CHECK(graph.addNode("a", "self.prune"));
CHECK(graph.addNode("b", "jitter"));
CHECK(graph.connect("a", "b"));
CHECK(graph.connect("b", "a"));
CHECK(!graph.validate());
CHECK(graph.getError().find("cycle") != std::string::npos);
CHECK(!graph.execute("a"));
CHECK(graph.getError().find("cycle") != std::string::npos);
CHECK(!graph.addNode("unknown", "not-an-operation"));
}
TEST_CASE("procgen.pointGraph.filtersProjectedTerrainSlope") {
PointSet source;
source.add(0.f, 0.f, 0.f);
source.add(1.f, 0.f, 0.f);
source.setNormal(0, 0.f, 1.f, 0.f);
source.setNormal(1, 1.f, 0.f, 0.f);
PointGraph graph;
CHECK(graph.addNode("source", "input"));
CHECK(graph.addNode("slope", "filter.slope"));
CHECK(graph.setNodePoints("source", &source));
CHECK(graph.connect("source", "slope"));
CHECK(graph.setNodeFloat("slope", "minDegrees", 0.f));
CHECK(graph.setNodeFloat("slope", "maxDegrees", 45.f));
CHECK(graph.validate());
std::unique_ptr<PointSet> result(graph.execute("slope"));
REQUIRE(bool(result));
CHECK_EQ(result->getCount(), 1);
CHECK_EQ(result->getNormalY(0), 1.f);
}
TEST_CASE("procgen.pointGraph.supportsBranchesAndNestedGraphs") {
PointSet source;
source.add(1.f, 0.f, 0.f);
PointGraph nested;
CHECK(nested.addNode("in", "input"));
CHECK(nested.addNode("move", "transform"));
CHECK(nested.setNodePoints("in", &source));
CHECK(nested.connect("in", "move"));
CHECK(nested.setNodeFloat("move", "x", 5.f));
PointGraph graph;
CHECK(graph.addNode("source", "input"));
CHECK(graph.addNode("nested", "subgraph"));
CHECK(graph.addNode("fallback", "transform"));
CHECK(graph.addNode("choose", "branch"));
CHECK(graph.setNodePoints("source", &source));
CHECK(graph.connect("source", "nested"));
CHECK(graph.setNodeSubgraph("nested", &nested, "in", "move"));
CHECK(graph.connect("source", "fallback"));
CHECK(graph.setNodeFloat("fallback", "x", -5.f));
CHECK(graph.connect("nested", "choose", 0));
CHECK(graph.connect("fallback", "choose", 1));
CHECK(graph.setNodeInt("choose", "condition", 1));
PointSet* result = graph.execute("choose");
REQUIRE(bool(result));
CHECK_EQ(result->getCount(), 1);
CHECK_EQ(result->getX(0), 6.f);
delete result;
}
TEST_CASE("procgen.pointGraph.reflectsOperationsForEditors") {
CHECK(PointGraph::getOperationCount() >= 15);
CHECK_EQ(PointGraph::getOperationInputCount("merge"), 2);
CHECK_EQ(PointGraph::getOperationInputCount("spatial.sample"), 0);
CHECK_EQ(PointGraph::getOperationParamCount("transform"), 7);
CHECK_EQ(PointGraph::getOperationParamKey("spatial.sample", 0), std::string("spacing"));
CHECK_EQ(PointGraph::getOperationParamKind("spatial.sample", 1), std::string("int"));
CHECK_EQ(PointGraph::getOperationParamDefault("branch", 0), std::string("false"));
CHECK_EQ(PointGraph::getOperationInputCount("filter.slope"), 1);
CHECK_EQ(PointGraph::getOperationInputCount("missing"), -1);
}
TEST_CASE("procgen.pointGraph.enforcesDeclaredPinsAndValidatesExternalSubgraphInput") {
PointGraph nested;
CHECK(nested.addNode("in", "input"));
CHECK(nested.addNode("move", "transform"));
CHECK(nested.connect("in", "move"));
PointGraph graph;
CHECK(graph.addNode("source", "input"));
CHECK(graph.addNode("nested", "subgraph"));
CHECK(graph.connect("source", "nested"));
CHECK(!graph.connect("source", "nested", 1));
CHECK(!graph.connect("source", "source", 0));
CHECK(graph.setNodeSubgraph("nested", &nested, "in", "move"));
PointSet input;
input.add(1.f, 2.f, 3.f);
CHECK(graph.setNodePoints("source", &input));
CHECK(graph.validate());
PointSet* output = graph.execute("nested");
REQUIRE(bool(output));
CHECK_EQ(output->getCount(), 1);
delete output;
}
TEST_CASE("procgen.pointGraph.definitionRoundTripsNestedTopologyAndParams") {
PointSet source;
source.add(1.f, 0.f, 0.f);
PointGraph nested;
nested.addNode("in", "input");
nested.addNode("move", "transform");
nested.setNodePoints("in", &source);
nested.connect("in", "move");
nested.setNodeFloat("move", "x", 5.f);
PointGraph original;
original.addNode("source", "input");
original.addNode("nested", "subgraph");
original.addNode("tag", "attribute.set.string");
original.setNodePoints("source", &source);
original.connect("source", "nested");
original.setNodeSubgraph("nested", &nested, "in", "move");
original.connect("nested", "tag");
original.setNodeString("tag", "attribute", "asset");
original.setNodeString("tag", "value", "oak \"old\"");
const std::string definition = original.serializeDefinition();
CHECK(definition.find("EVPCG_POINT_GRAPH 1") == 0);
PointGraph loaded;
CHECK(loaded.deserializeDefinition(definition));
CHECK_EQ(loaded.getNodeCount(), 3);
CHECK_EQ(loaded.getInputNode("tag", 0), std::string("nested"));
CHECK(loaded.setNodePoints("source", &source));
PointSet* result = loaded.execute("tag");
REQUIRE(bool(result));
CHECK_EQ(result->getX(0), 6.f);
CHECK_EQ(result->getStringAttribute(0, "asset", ""), std::string("oak \"old\""));
delete result;
CHECK(!loaded.deserializeDefinition("broken"));
CHECK(loaded.hasNode("source"));
CHECK(!loaded.deserializeDefinition(
"EVPCG_POINT_GRAPH 1\nNODE \"move\" \"transform\"\nS \"move\" \"x\" \"bad\"\nEND\n"));
CHECK(loaded.hasNode("source"));
}
TEST_CASE("procgen.pointGraph.invalidatesOnlyChangedNodeDescendants") {
PointSet points;
points.add(1.f, 0.f, 0.f);
PointGraph graph;
CHECK(graph.addNode("source", "input"));
CHECK(graph.addNode("left", "transform"));
CHECK(graph.addNode("right", "transform"));
CHECK(graph.connect("source", "left"));
CHECK(graph.connect("source", "right"));
CHECK(graph.setNodePoints("source", &points));
PointSet* left = graph.execute("left");
PointSet* right = graph.execute("right");
REQUIRE(bool(left));
REQUIRE(bool(right));
delete right;
delete left;
const uint64_t revision = graph.getRevision();
CHECK(graph.setNodeFloat("left", "x", 5.f));
CHECK(graph.getRevision() > revision);
PointSet* sourceCache = graph.getNodeOutput("source");
PointSet* rightCache = graph.getNodeOutput("right");
CHECK(bool(sourceCache));
CHECK(bool(rightCache));
CHECK(!graph.getNodeOutput("left"));
delete rightCache;
delete sourceCache;
}
TEST_CASE("procgen.pointGraph.definitionIsStableAcrossParameterInsertionOrder") {
PointGraph first;
PointGraph second;
CHECK(first.addNode("move", "transform"));
CHECK(second.addNode("move", "transform"));
CHECK(first.addNode("tag", "attribute.set.string"));
CHECK(second.addNode("tag", "attribute.set.string"));
CHECK(first.setNodeFloat("move", "z", 3.f));
CHECK(first.setNodeFloat("move", "x", 1.f));
CHECK(first.setNodeString("tag", "value", "oak"));
CHECK(first.setNodeString("tag", "attribute", "asset"));
CHECK(second.setNodeString("tag", "attribute", "asset"));
CHECK(second.setNodeString("tag", "value", "oak"));
CHECK(second.setNodeFloat("move", "x", 1.f));
CHECK(second.setNodeFloat("move", "z", 3.f));
CHECK_EQ(first.serializeDefinition(), second.serializeDefinition());
CHECK(!first.setNodeString("move", "typo", "rejected"));
CHECK(!first.setNodeInt("move", "x", 1));
CHECK(!first.setNodeFloat("tag", "value", 1.f));
}
TEST_CASE("procgen.pointGraph.exposesTypedInstanceParameters") {
PointSet points;
points.add(1.f, 0.f, 0.f);
PointGraph graph;
CHECK(graph.addNode("source", "input"));
CHECK(graph.addNode("move", "transform"));
CHECK(graph.connect("source", "move"));
CHECK(graph.setNodePoints("source", &points));
CHECK(graph.setNodeFloat("move", "x", 2.f));
CHECK(graph.exposeParameter("offset", "move", "x"));
CHECK_EQ(graph.getParameterCount(), 1);
CHECK_EQ(graph.getParameterName(0), std::string("offset"));
CHECK_EQ(graph.getParameterKind("offset"), std::string("float"));
CHECK_EQ(graph.getParameterFloat("offset", -1.f), 2.f);
CHECK(!graph.exposeParameter("alias", "move", "x"));
CHECK(!graph.exposeParameter("bad", "move", "missing"));
CHECK(!graph.setParameterInt("offset", 7));
PointSet* result = graph.execute("move");
REQUIRE(bool(result));
CHECK_EQ(result->getX(0), 3.f);
delete result;
CHECK(graph.setParameterFloat("offset", 5.f));
CHECK(graph.hasParameterOverride("offset"));
CHECK_EQ(graph.getParameterFloat("offset", -1.f), 5.f);
result = graph.execute("move");
REQUIRE(bool(result));
CHECK_EQ(result->getX(0), 6.f);
delete result;
const std::string definition = graph.serializeDefinition();
PointGraph loaded;
CHECK(loaded.deserializeDefinition(definition));
CHECK_EQ(loaded.getParameterKind("offset"), std::string("float"));
CHECK(!loaded.hasParameterOverride("offset"));
CHECK_EQ(loaded.getParameterFloat("offset", -1.f), 2.f);
CHECK(loaded.setNodePoints("source", &points));
result = loaded.execute("move");
REQUIRE(bool(result));
CHECK_EQ(result->getX(0), 3.f);
delete result;
CHECK(graph.clearParameterOverride("offset"));
CHECK(!graph.hasParameterOverride("offset"));
CHECK_EQ(graph.getParameterFloat("offset", -1.f), 2.f);
CHECK(graph.removeNode("move"));
CHECK_EQ(graph.getParameterCount(), 0);
}
TEST_CASE("procgen.pointGraph.serializesExposedParametersDeterministically") {
PointGraph first;
PointGraph second;
for (PointGraph* graph : {&first, &second}) {
CHECK(graph->addNode("move", "transform"));
CHECK(graph->addNode("tag", "attribute.set.string"));
}
CHECK(first.exposeParameter("zOffset", "move", "z"));
CHECK(first.exposeParameter("asset", "tag", "value"));
CHECK(second.exposeParameter("asset", "tag", "value"));
CHECK(second.exposeParameter("zOffset", "move", "z"));
CHECK_EQ(first.serializeDefinition(), second.serializeDefinition());
}
TEST_CASE("procgen.pointGraph.cooperativelyBudgetsAndCancelsExecution") {
PointSet points;
points.add(0.f, 0.f, 0.f);
PointGraph graph;
CHECK(graph.addNode("source", "input"));
CHECK(graph.addNode("first", "transform"));
CHECK(graph.addNode("second", "transform"));
CHECK(graph.connect("source", "first"));
CHECK(graph.connect("first", "second"));
CHECK(graph.setNodePoints("source", &points));
graph.setExecutionNodeBudget(2);
CHECK_EQ(graph.getExecutionNodeBudget(), 2);
CHECK(!graph.execute("second"));
CHECK(graph.wasCancelled());
CHECK(graph.getError().find("budget exceeded") != std::string::npos);
PointSet* partial = graph.getNodeOutput("first");
REQUIRE(bool(partial));
delete partial;
graph.setExecutionNodeBudget(3);
PointSet* completed = graph.execute("second");
REQUIRE(bool(completed));
CHECK(!graph.wasCancelled());
CHECK(graph.getCacheHitCount() > 0);
delete completed;
graph.requestCancel();
CHECK(!graph.execute("second"));
CHECK(graph.wasCancelled());
CHECK(graph.getError().find("cancelled") != std::string::npos);
graph.resetCancellation();
CHECK(!graph.wasCancelled());
completed = graph.execute("second");
REQUIRE(bool(completed));
delete completed;
}
TEST_CASE("procgen.pointGraph.copiesSourcePointsAcrossTargetsWithBoundedOutput") {
PointSet source;
const int sourcePoint = source.add(1.f, 2.f, 0.f);
source.setPointSeed(sourcePoint, 11);
source.setFloatAttribute(sourcePoint, "source", 2.f);
source.setStringAttribute(sourcePoint, "shared", "source");
PointSet targets;
const int firstTarget = targets.add(10.f, 20.f, 30.f);
targets.setYaw(firstTarget, 90.f);
targets.setScale(firstTarget, 2.f, 3.f, 4.f);
targets.setDensity(firstTarget, 0.5f);
targets.setPointSeed(firstTarget, 101);
targets.setFloatAttribute(firstTarget, "target", 3.f);
targets.setStringAttribute(firstTarget, "shared", "target");
targets.add(-10.f, 0.f, 0.f);
PointGraph graph;
CHECK(graph.addNode("source", "input"));
CHECK(graph.addNode("targets", "input"));
CHECK(graph.addNode("copies", "copy.points"));
CHECK(graph.setNodePoints("source", &source));
CHECK(graph.setNodePoints("targets", &targets));
CHECK(graph.connect("source", "copies", 0));
CHECK(graph.connect("targets", "copies", 1));
CHECK(graph.setNodeInt("copies", "maxPoints", 2));
PointSet* result = graph.execute("copies");
REQUIRE(bool(result));
CHECK_EQ(result->getCount(), 2);
CHECK(std::abs(result->getX(0) - 10.f) < 0.0001f);
CHECK_EQ(result->getY(0), 26.f);
CHECK(std::abs(result->getZ(0) - 32.f) < 0.0001f);
CHECK_EQ(result->getYaw(0), 90.f);
CHECK_EQ(result->getScaleX(0), 2.f);
CHECK_EQ(result->getDensity(0), 0.5f);
CHECK_EQ(result->getFloatAttribute(0, "target", -1.f), 3.f);
CHECK_EQ(result->getFloatAttribute(0, "source", -1.f), 2.f);
CHECK_EQ(result->getStringAttribute(0, "shared", ""), std::string("source"));
delete result;
CHECK(graph.setNodeInt("copies", "maxPoints", 1));
CHECK(!graph.execute("copies"));
CHECK(graph.getError().find("maxPoints") != std::string::npos);
}
TEST_CASE("procgen.pointGraph.validatesEveryRequiredInput") {
PointSet points;
PointGraph graph;
CHECK(graph.addNode("source", "input"));
CHECK(graph.addNode("copies", "copy.points"));
CHECK(graph.setNodePoints("source", &points));
CHECK(graph.connect("source", "copies", 0));
CHECK(!graph.validate());
CHECK(graph.getError().find("input 1") != std::string::npos);
}
TEST_CASE("procgen.pointGraph.remapsDensityAndComputesFloatMetadata") {
PointSet points;
const int first = points.add(0.f, 0.f, 0.f);
const int second = points.add(1.f, 0.f, 0.f);
points.setDensity(first, -1.f);
points.setDensity(second, 0.5f);
points.setFloatAttribute(first, "age", 3.f);
PointGraph graph;
CHECK(graph.addNode("source", "input"));
CHECK(graph.addNode("density", "density.remap"));
CHECK(graph.addNode("math", "attribute.math.float"));
CHECK(graph.setNodePoints("source", &points));
CHECK(graph.connect("source", "density"));
CHECK(graph.connect("density", "math"));
CHECK(graph.setNodeFloat("density", "inputMin", 0.f));
CHECK(graph.setNodeFloat("density", "inputMax", 1.f));
CHECK(graph.setNodeFloat("density", "outputMin", 10.f));
CHECK(graph.setNodeFloat("density", "outputMax", 20.f));
CHECK(graph.setNodeString("math", "attribute", "age"));
CHECK(graph.setNodeString("math", "outputAttribute", "score"));
CHECK(graph.setNodeString("math", "operation", "multiply"));
CHECK(graph.setNodeFloat("math", "operand", 2.f));
CHECK(graph.setNodeFloat("math", "defaultValue", 4.f));
PointSet* result = graph.execute("math");
REQUIRE(bool(result));
CHECK_EQ(result->getDensity(0), 10.f);
CHECK_EQ(result->getDensity(1), 15.f);
CHECK_EQ(result->getFloatAttribute(0, "score", -1.f), 6.f);
CHECK_EQ(result->getFloatAttribute(1, "score", -1.f), 8.f);
delete result;
CHECK(graph.setNodeString("math", "operation", "divide"));
CHECK(graph.setNodeFloat("math", "operand", 0.f));
CHECK(!graph.execute("math"));
CHECK(graph.getError().find("divide by zero") != std::string::npos);
CHECK(graph.setNodeFloat("density", "inputMax", 0.f));
CHECK(!graph.execute("density"));
CHECK(graph.getError().find("non-zero input range") != std::string::npos);
}
TEST_CASE("procgen.pointGraph.cachesSpatialMetricsForDebugVisualization") {
PointSet points;
const int first = points.add(-2.f, 3.f, 4.f);
const int second = points.add(6.f, -1.f, 8.f);
points.setDensity(first, 0.25f);
points.setDensity(second, 0.75f);
PointGraph graph;
CHECK(graph.addNode("source", "input"));
CHECK(graph.setNodePoints("source", &points));
PointSet* output = graph.execute("source");
REQUIRE(bool(output));
delete output;
CHECK_EQ(graph.getMetricCount(), 1);
CHECK_EQ(graph.getMetricMinX(0), -2.f);
CHECK_EQ(graph.getMetricMinY(0), -1.f);
CHECK_EQ(graph.getMetricMinZ(0), 4.f);
CHECK_EQ(graph.getMetricMaxX(0), 6.f);
CHECK_EQ(graph.getMetricMaxY(0), 3.f);
CHECK_EQ(graph.getMetricMaxZ(0), 8.f);
CHECK_EQ(graph.getMetricAverageDensity(0), 0.5f);
output = graph.execute("source");
REQUIRE(bool(output));
delete output;
CHECK(graph.isMetricCacheHit(0));
CHECK_EQ(graph.getMetricMinX(0), -2.f);
CHECK_EQ(graph.getMetricAverageDensity(0), 0.5f);
}
TEST_CASE("procgen.pointGraph.instantiatesIsolatedRuntimeState") {
PointSet points;
points.add(1.f, 0.f, 0.f);
PointGraph asset;
CHECK(asset.addNode("source", "input"));
CHECK(asset.addNode("move", "transform"));
CHECK(asset.connect("source", "move"));
CHECK(asset.setNodePoints("source", &points));
CHECK(asset.setNodeFloat("move", "x", 2.f));
CHECK(asset.exposeParameter("offset", "move", "x"));
CHECK(asset.setParameterFloat("offset", 9.f));
PointGraph* instance = asset.instantiate();
REQUIRE(bool(instance));
CHECK(!instance->hasParameterOverride("offset"));
CHECK_EQ(instance->getParameterFloat("offset", -1.f), 2.f);
CHECK(!instance->execute("move"));
CHECK(instance->getError().find("no points") != std::string::npos);
CHECK(instance->setNodePoints("source", &points));
CHECK(instance->setParameterFloat("offset", 4.f));
PointSet* output = instance->execute("move");
REQUIRE(bool(output));
CHECK_EQ(output->getX(0), 5.f);
delete output;
CHECK_EQ(asset.getParameterFloat("offset", -1.f), 9.f);
delete instance;
}
TEST_CASE("procgen.pointGraph.generatesBiomeThroughReflectedNode") {
SpatialData domain = SpatialData::box(0.f, 0.f, 0.f, 4.f, 0.f, 4.f);
BiomeRules rules;
CHECK(rules.addLayer("forest", &domain, 1, 1.f));
CHECK(rules.addAsset("forest", "oak", 1.f, 1.f, 1.f, false));
PointGraph graph;
CHECK(graph.addNode("biome", "biome.generate"));
CHECK(graph.setNodeSpatial("biome", &domain));
CHECK(graph.setNodeBiomeRules("biome", &rules));
CHECK(graph.setNodeFloat("biome", "spacing", 2.f));
CHECK(graph.setNodeInt("biome", "seed", 42));
CHECK(graph.validate());
PointSet* output = graph.execute("biome");
REQUIRE(bool(output));
CHECK_EQ(output->getCount(), 9);
CHECK_EQ(output->getStringAttribute(0, "biome", ""), std::string("forest"));
CHECK_EQ(output->getStringAttribute(0, "asset", ""), std::string("oak"));
delete output;
}
TEST_CASE("procgen.pointGraph.expandsShapeGrammarAndRebindsExternalAssets") {
PointSet controlPoints;
controlPoints.add(0.f, 0.f, 0.f);
controlPoints.add(6.f, 0.f, 0.f);
ShapeGrammar grammar;
CHECK(grammar.addModule("A", "wall", 2.f, 1.f));
PointGraph asset;
CHECK(asset.addNode("path", "input"));
CHECK(asset.addNode("facade", "grammar.generate"));
CHECK(asset.connect("path", "facade"));
CHECK(asset.setNodePoints("path", &controlPoints));
CHECK(asset.setNodeShapeGrammar("facade", &grammar));
CHECK(asset.setNodeString("facade", "grammar", "A+"));
CHECK(asset.validate());
PointSet* output = asset.execute("facade");
REQUIRE(bool(output));
CHECK_EQ(output->getCount(), 3);
CHECK_EQ(output->getStringAttribute(0, "asset", ""), std::string("wall"));
delete output;
PointGraph* instance = asset.instantiate();
REQUIRE(bool(instance));
CHECK(instance->setNodePoints("path", &controlPoints));
CHECK(!instance->validate());
CHECK(instance->getError().find("shape grammar") != std::string::npos);
CHECK(instance->setNodeShapeGrammar("facade", &grammar));
CHECK(instance->validate());
output = instance->execute("facade");
REQUIRE(bool(output));
CHECK_EQ(output->getCount(), 3);
delete output;
delete instance;
}
Reference in new issue View Git Blame Copy Permalink