Partial layered generator implementation

common/addons/chunk-generator-layered/build.gradle.kts

@@ -0,0 +1,12 @@
+version = version("0.1.0")
+
+dependencies {
+    compileOnlyApi(project(":common:addons:manifest-addon-loader"))
+    
+    implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama)
+    testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama)
+}
+
+tasks.named<com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar>("shadowJar") {
+    relocate("net.jafama", "com.dfsek.terra.addons.chunkgenerator.lib.jafama")
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/LayeredChunkGeneratorAddon.java

@@ -0,0 +1,85 @@
+package com.dfsek.terra.addons.chunkgenerator;
+
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import com.dfsek.terra.addons.chunkgenerator.config.LayeredChunkGeneratorPackConfigTemplate;
+import com.dfsek.terra.addons.chunkgenerator.config.palette.BlockLayerPaletteTemplate;
+import com.dfsek.terra.addons.chunkgenerator.config.predicate.BelowLayerPredicateTemplate;
+import com.dfsek.terra.addons.chunkgenerator.config.predicate.RangeLayerPredicateTemplate;
+import com.dfsek.terra.addons.chunkgenerator.config.predicate.SamplerLayerPredicateTemplate;
+import com.dfsek.terra.addons.chunkgenerator.config.resolve.PaletteLayerResolverTemplate;
+import com.dfsek.terra.addons.chunkgenerator.config.resolve.PredicateLayerResolverTemplate;
+import com.dfsek.terra.addons.chunkgenerator.generation.LayeredChunkGenerator;
+import com.dfsek.terra.addons.chunkgenerator.layer.palette.LayerPalette;
+import com.dfsek.terra.addons.chunkgenerator.layer.predicate.LayerPredicate;
+import com.dfsek.terra.addons.chunkgenerator.layer.resolve.LayerResolver;
+import com.dfsek.terra.addons.manifest.api.AddonInitializer;
+import com.dfsek.terra.api.Platform;
+import com.dfsek.terra.api.addon.BaseAddon;
+import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent;
+import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
+import com.dfsek.terra.api.inject.annotations.Inject;
+
+import com.dfsek.terra.api.registry.CheckedRegistry;
+import com.dfsek.terra.api.util.reflection.TypeKey;
+import com.dfsek.terra.api.world.chunk.generation.util.provider.ChunkGeneratorProvider;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.function.Supplier;
+
+
+public class LayeredChunkGeneratorAddon implements AddonInitializer {
+    
+    private static final Logger logger = LoggerFactory.getLogger(LayeredChunkGenerator.class);
+    
+    public static final TypeKey<Supplier<ObjectTemplate<LayerPalette>>> LAYER_PALETTE_TOKEN = new TypeKey<>() {
+    };
+    
+    public static final TypeKey<Supplier<ObjectTemplate<LayerResolver>>> LAYER_RESOLVER_TOKEN = new TypeKey<>() {
+    };
+    
+    public static final TypeKey<Supplier<ObjectTemplate<LayerPredicate>>> LAYER_PREDICATE_TOKEN = new TypeKey<>() {
+    };
+    
+    @Inject
+    private Platform platform;
+    
+    @Inject
+    private BaseAddon addon;
+    
+    @Override
+    public void initialize() {
+        
+        platform.getEventManager()
+                .getHandler(FunctionalEventHandler.class)
+                .register(addon, ConfigPackPreLoadEvent.class)
+                .priority(50)
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<LayerPalette>>> paletteRegistry = event.getPack().getOrCreateRegistry(LAYER_PALETTE_TOKEN);
+                    paletteRegistry.register(addon.key("BLOCK"), BlockLayerPaletteTemplate::new);
+                })
+                .then(event -> {
+                    logger.info("Registering LayerResolvers..");
+                    LayeredChunkGeneratorPackConfigTemplate config = event.loadTemplate(new LayeredChunkGeneratorPackConfigTemplate());
+                    CheckedRegistry<Supplier<ObjectTemplate<LayerResolver>>> resolverRegistry = event.getPack().getOrCreateRegistry(LAYER_RESOLVER_TOKEN);
+                    resolverRegistry.register(addon.key("PREDICATE"), PredicateLayerResolverTemplate::new);
+                    resolverRegistry.register(addon.key("PALETTE"), () -> new PaletteLayerResolverTemplate(config.getPalettes()));
+                })
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<LayerPredicate>>> predicateRegistry = event.getPack().getOrCreateRegistry(LAYER_PREDICATE_TOKEN);
+                    predicateRegistry.register(addon.key("BELOW"), BelowLayerPredicateTemplate::new);
+                    predicateRegistry.register(addon.key("RANGE"), RangeLayerPredicateTemplate::new);
+                    predicateRegistry.register(addon.key("SAMPLER"), SamplerLayerPredicateTemplate::new);
+                })
+                .then(event -> {
+                    LayeredChunkGeneratorPackConfigTemplate config = event.loadTemplate(new LayeredChunkGeneratorPackConfigTemplate());
+                    event.getPack()
+                         .getOrCreateRegistry(ChunkGeneratorProvider.class)
+                         .register(addon.key("LAYERED"),
+                                   pack -> new LayeredChunkGenerator(platform, config.getResolver()));
+                })
+                .failThrough();
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/LayeredChunkGeneratorPackConfigTemplate.java

@@ -0,0 +1,36 @@
+package com.dfsek.terra.addons.chunkgenerator.config;
+
+import com.dfsek.tectonic.api.config.template.ConfigTemplate;
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.addons.chunkgenerator.layer.palette.LayerPalette;
+import com.dfsek.terra.addons.chunkgenerator.layer.resolve.LayerResolver;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+import java.util.Map;
+
+
+public class LayeredChunkGeneratorPackConfigTemplate implements ConfigTemplate {
+    @Value("generation.sampler")
+    private @Meta NoiseSampler sampler;
+    
+    @Value("generation.resolver")
+    private @Meta LayerResolver resolver;
+    
+    @Value("generation.palettes")
+    private @Meta Map<String, LayerPalette> palettes;
+    
+    public Map<String, LayerPalette> getPalettes() {
+        return palettes;
+    }
+    
+    public NoiseSampler getSampler() {
+        return sampler;
+    }
+    
+    public LayerResolver getResolver() {
+        return resolver;
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BlockLayerPaletteTemplate.java

@@ -0,0 +1,20 @@
+package com.dfsek.terra.addons.chunkgenerator.config.palette;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import com.dfsek.terra.addons.chunkgenerator.layer.palette.BlockLayerPalette;
+import com.dfsek.terra.addons.chunkgenerator.layer.palette.LayerPalette;
+import com.dfsek.terra.api.block.state.BlockState;
+
+
+public class BlockLayerPaletteTemplate implements ObjectTemplate<LayerPalette> {
+    
+    @Value("block")
+    private BlockState block;
+    
+    @Override
+    public BlockLayerPalette get() {
+        return new BlockLayerPalette(block);
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/predicate/BelowLayerPredicateTemplate.java

@@ -0,0 +1,20 @@
+package com.dfsek.terra.addons.chunkgenerator.config.predicate;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import com.dfsek.terra.addons.chunkgenerator.layer.predicate.BelowLayerPredicate;
+import com.dfsek.terra.addons.chunkgenerator.layer.predicate.LayerPredicate;
+import com.dfsek.terra.api.config.meta.Meta;
+
+
+public class BelowLayerPredicateTemplate implements ObjectTemplate<LayerPredicate> {
+    
+    @Value("y")
+    private @Meta int y;
+    
+    @Override
+    public LayerPredicate get() {
+        return new BelowLayerPredicate(y);
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/predicate/RangeLayerPredicateTemplate.java

@@ -0,0 +1,20 @@
+package com.dfsek.terra.addons.chunkgenerator.config.predicate;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import com.dfsek.terra.addons.chunkgenerator.layer.predicate.LayerPredicate;
+import com.dfsek.terra.addons.chunkgenerator.layer.predicate.RangeLayerPredicate;
+import com.dfsek.terra.api.util.Range;
+
+
+public class RangeLayerPredicateTemplate implements ObjectTemplate<LayerPredicate> {
+    
+    @Value("range")
+    private Range range;
+    
+    @Override
+    public LayerPredicate get() {
+        return new RangeLayerPredicate(range);
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/predicate/SamplerLayerPredicateTemplate.java

@@ -0,0 +1,21 @@
+package com.dfsek.terra.addons.chunkgenerator.config.predicate;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import com.dfsek.terra.addons.chunkgenerator.layer.predicate.LayerPredicate;
+import com.dfsek.terra.addons.chunkgenerator.layer.predicate.SamplerLayerPredicate;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+
+public class SamplerLayerPredicateTemplate implements ObjectTemplate<LayerPredicate> {
+    
+    @Value("sampler")
+    private @Meta NoiseSampler sampler;
+    
+    @Override
+    public LayerPredicate get() {
+        return new SamplerLayerPredicate(sampler);
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/resolve/PaletteLayerResolverTemplate.java

@@ -0,0 +1,37 @@
+package com.dfsek.terra.addons.chunkgenerator.config.resolve;
+
+import com.dfsek.tectonic.api.config.template.ValidatedConfigTemplate;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import com.dfsek.tectonic.api.exception.ValidationException;
+
+import com.dfsek.terra.addons.chunkgenerator.layer.palette.LayerPalette;
+import com.dfsek.terra.addons.chunkgenerator.layer.resolve.LayerResolver;
+import com.dfsek.terra.addons.chunkgenerator.layer.resolve.PaletteLayerResolver;
+
+import java.util.Map;
+
+
+public class PaletteLayerResolverTemplate implements ObjectTemplate<LayerResolver>, ValidatedConfigTemplate {
+    
+    private final Map<String, LayerPalette> palettes;
+    
+    public PaletteLayerResolverTemplate(Map<String, LayerPalette> palettes) {
+        this.palettes = palettes;
+    }
+    
+    @Value("palette")
+    private String palette;
+    
+    @Override
+    public LayerResolver get() {
+        return new PaletteLayerResolver(palettes.get(palette));
+    }
+    
+    @Override
+    public boolean validate() throws ValidationException {
+        if(!palettes.containsKey(palette)) throw new ValidationException("The palette " + palette + " does not exist!");
+        return true;
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/resolve/PredicateLayerResolverTemplate.java

@@ -0,0 +1,29 @@
+package com.dfsek.terra.addons.chunkgenerator.config.resolve;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import com.dfsek.terra.addons.chunkgenerator.layer.predicate.LayerPredicate;
+import com.dfsek.terra.addons.chunkgenerator.layer.resolve.LayerResolver;
+import com.dfsek.terra.addons.chunkgenerator.layer.resolve.PredicateLayerResolver;
+import com.dfsek.terra.api.config.meta.Meta;
+
+
+public class PredicateLayerResolverTemplate implements ObjectTemplate<LayerResolver> {
+    
+    @Value("if")
+    private @Meta LayerPredicate predicate;
+    
+    @Value("then")
+    private @Meta LayerResolver trueResolver;
+    
+    @Value("else")
+    private @Meta LayerResolver falseResolver;
+    
+    
+    @Override
+    public PredicateLayerResolver get() {
+        return new PredicateLayerResolver(predicate, trueResolver, falseResolver);
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/LayeredChunkGenerator.java

@@ -0,0 +1,88 @@
+package com.dfsek.terra.addons.chunkgenerator.generation;
+
+import com.dfsek.terra.addons.chunkgenerator.layer.palette.LayerPalette;
+import com.dfsek.terra.addons.chunkgenerator.layer.resolve.LayerResolver;
+import com.dfsek.terra.api.Platform;
+import com.dfsek.terra.api.block.state.BlockState;
+import com.dfsek.terra.api.util.Column;
+import com.dfsek.terra.api.world.biome.Biome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+import com.dfsek.terra.api.world.chunk.generation.ChunkGenerator;
+import com.dfsek.terra.api.world.chunk.generation.ProtoChunk;
+import com.dfsek.terra.api.world.chunk.generation.util.Palette;
+import com.dfsek.terra.api.world.info.WorldProperties;
+
+import org.jetbrains.annotations.NotNull;
+
+
+public class LayeredChunkGenerator implements ChunkGenerator {
+    
+    private final Platform platform;
+    private final LayerResolver resolver;
+    
+    public LayeredChunkGenerator(Platform platform, LayerResolver resolver) {
+        this.platform = platform;
+        this.resolver = resolver;
+    }
+    
+    @Override
+    public void generateChunkData(@NotNull ProtoChunk chunk, @NotNull WorldProperties world, @NotNull BiomeProvider biomeProvider,
+                                  int chunkX, int chunkZ) {
+    
+        platform.getProfiler().push("chunk_base_layered");
+        
+        int xOrig = (chunkX << 4);
+        int zOrig = (chunkZ << 4);
+        long seed = world.getSeed();
+        
+        for(int x = 0; x < 16; x++) {
+            for(int z = 0; z < 16; z++) {
+    
+                int cx = xOrig + x;
+                int cz = zOrig + z;
+                int paletteLevel = 0;
+                LayerPalette previousLayerPalette = null;
+                Column<Biome> biomeColumn = biomeProvider.getColumn(cx, cz, world);
+                
+                for(int y = world.getMaxHeight() - 1; y >= world.getMinHeight(); y--) {
+                    
+                    Biome biome = biomeColumn.get(y);
+                    
+                    LayerPalette layerPalette = resolver.resolve(seed, biome, x, y, z);
+                    
+                    if (previousLayerPalette == layerPalette) {
+                        paletteLevel++;
+                    } else {
+                        paletteLevel = 0;
+                    }
+                    previousLayerPalette = layerPalette;
+                    
+                    Palette palette = layerPalette.get(seed, biome, x, y, z);
+    
+                    chunk.setBlock(cx, y, cz, palette.get(paletteLevel, x, y, z, seed));
+                    
+                }
+            }
+        }
+    
+        platform.getProfiler().pop("chunk_base_layered");
+    }
+    
+    @Override
+    public BlockState getBlock(WorldProperties world, int x, int y, int z, BiomeProvider biomeProvider) {
+        long seed = world.getSeed();
+        Biome biome = biomeProvider.getBiome(x, y, z, seed);
+        int layer = 0; // Default to layer 0 for now
+        return resolver.resolve(seed, biome, x, y, z)
+                       .get(seed, biome, x, y, z)
+                       .get(layer, x, y, z, seed);
+    }
+    
+    @Override
+    public Palette getPalette(int x, int y, int z, WorldProperties world, BiomeProvider biomeProvider) {
+        long seed = world.getSeed();
+        Biome biome = biomeProvider.getBiome(x, y, z, seed);
+        return resolver.resolve(seed, biome, x, y, z)
+                       .get(seed, biome, x, y, z);
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/layer/palette/BlockLayerPalette.java

@@ -0,0 +1,27 @@
+package com.dfsek.terra.addons.chunkgenerator.layer.palette;
+
+import com.dfsek.terra.api.block.state.BlockState;
+import com.dfsek.terra.api.world.biome.Biome;
+import com.dfsek.terra.api.world.chunk.generation.util.Palette;
+
+
+public class BlockLayerPalette implements LayerPalette {
+    
+    private final Palette palette;
+    
+    public BlockLayerPalette(BlockState block) {
+        this.palette = new SingletonPalette(block);
+    }
+    
+    @Override
+    public Palette get(long seed, Biome biome, int x, int y, int z) {
+        return palette;
+    }
+    
+    private record SingletonPalette(BlockState blockState) implements Palette {
+        @Override
+            public BlockState get(int layer, double x, double y, double z, long seed) {
+                return blockState;
+            }
+        }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/layer/palette/LayerPalette.java

@@ -0,0 +1,12 @@
+package com.dfsek.terra.addons.chunkgenerator.layer.palette;
+
+import com.dfsek.terra.api.world.biome.Biome;
+import com.dfsek.terra.api.world.chunk.generation.util.Palette;
+import com.dfsek.terra.api.world.info.WorldProperties;
+
+
+public interface LayerPalette {
+    
+    Palette get(long seed, Biome biome, int x, int y, int z);
+    
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/layer/predicate/BelowLayerPredicate.java

@@ -0,0 +1,18 @@
+package com.dfsek.terra.addons.chunkgenerator.layer.predicate;
+
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public class BelowLayerPredicate implements LayerPredicate {
+    
+    private final int y;
+    
+    public BelowLayerPredicate(int y) {
+        this.y = y;
+    }
+    
+    @Override
+    public boolean test(long seed, Biome biome, int x, int y, int z) {
+        return y < this.y;
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/layer/predicate/LayerPredicate.java

@@ -0,0 +1,8 @@
+package com.dfsek.terra.addons.chunkgenerator.layer.predicate;
+
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public interface LayerPredicate {
+    boolean test(long seed, Biome biome, int x, int y, int z);
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/layer/predicate/RangeLayerPredicate.java

@@ -0,0 +1,18 @@
+package com.dfsek.terra.addons.chunkgenerator.layer.predicate;
+
+import com.dfsek.terra.api.util.Range;
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public class RangeLayerPredicate implements LayerPredicate {
+    
+    private final Range range;
+    
+    public RangeLayerPredicate(Range range) {
+        this.range = range;
+    }
+    @Override
+    public boolean test(long seed, Biome biome, int x, int y, int z) {
+        return range.isInRange(y);
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/layer/predicate/SamplerLayerPredicate.java

@@ -0,0 +1,20 @@
+package com.dfsek.terra.addons.chunkgenerator.layer.predicate;
+
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public class SamplerLayerPredicate implements LayerPredicate {
+    
+    private final NoiseSampler sampler;
+    
+    public SamplerLayerPredicate(NoiseSampler sampler) {
+        this.sampler = sampler;
+    }
+    
+    
+    @Override
+    public boolean test(long seed, Biome biome, int x, int y, int z) {
+        return sampler.noise(seed, x, y, z) > 0;
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/layer/resolve/LayerResolver.java

@@ -0,0 +1,8 @@
+package com.dfsek.terra.addons.chunkgenerator.layer.resolve;
+
+import com.dfsek.terra.addons.chunkgenerator.layer.palette.LayerPalette;
+import com.dfsek.terra.api.world.biome.Biome;
+
+public interface LayerResolver {
+    LayerPalette resolve(long seed, Biome biome, int x, int y, int z);
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/layer/resolve/PaletteLayerResolver.java

@@ -0,0 +1,18 @@
+package com.dfsek.terra.addons.chunkgenerator.layer.resolve;
+
+import com.dfsek.terra.addons.chunkgenerator.layer.palette.LayerPalette;
+import com.dfsek.terra.api.world.biome.Biome;
+
+public class PaletteLayerResolver implements LayerResolver {
+    
+    private final LayerPalette palette;
+    
+    public PaletteLayerResolver(LayerPalette palette) {
+        this.palette = palette;
+    }
+    
+    @Override
+    public LayerPalette resolve(long seed, Biome biome, int x, int y, int z) {
+        return palette;
+    }
+}

common/addons/chunk-generator-layered/src/main/java/com/dfsek/terra/addons/chunkgenerator/layer/resolve/PredicateLayerResolver.java

@@ -0,0 +1,26 @@
+package com.dfsek.terra.addons.chunkgenerator.layer.resolve;
+
+import com.dfsek.terra.addons.chunkgenerator.layer.palette.LayerPalette;
+import com.dfsek.terra.addons.chunkgenerator.layer.predicate.LayerPredicate;
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public class PredicateLayerResolver implements LayerResolver {
+    
+    private final LayerPredicate predicate;
+    
+    private final LayerResolver trueResolver;
+    
+    private final LayerResolver falseResolver;
+    
+    public PredicateLayerResolver(LayerPredicate predicate, LayerResolver trueResolver, LayerResolver falseResolver) {
+        this.predicate = predicate;
+        this.trueResolver = trueResolver;
+        this.falseResolver = falseResolver;
+    }
+    
+    @Override
+    public LayerPalette resolve(long seed, Biome biome, int x, int y, int z) {
+        return predicate.test(seed, biome, x, y, z) ? trueResolver.resolve(seed, biome, x, y, z) : falseResolver.resolve(seed, biome, x, y, z);
+    }
+}

common/addons/chunk-generator-layered/src/main/resources/terra.addon.yml

@@ -0,0 +1,12 @@
+schema-version: 1
+contributors:
+  - Terra contributors
+id: chunk-generator-layered
+version: @VERSION@
+entrypoints:
+  - "com.dfsek.terra.addons.chunkgenerator.LayeredChunkGeneratorAddon"
+website:
+  issues: https://github.com/PolyhedralDev/Terra/issues
+  source: https://github.com/PolyhedralDev/Terra
+  docs: https://terra.polydev.org
+license: MIT License