Merge branch 'ver/6.4.0' into dev/layered-generator

common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java

@@ -17,10 +17,17 @@
 
 package com.dfsek.terra.config.loaders;
 
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
 import com.dfsek.tectonic.api.depth.DepthTracker;
 import com.dfsek.tectonic.api.exception.LoadException;
 import com.dfsek.tectonic.api.loader.ConfigLoader;
 import com.dfsek.tectonic.api.loader.type.TypeLoader;
+
+import com.dfsek.tectonic.impl.MapConfiguration;
+
+import com.dfsek.terra.api.config.meta.Meta;
+
 import org.jetbrains.annotations.NotNull;
 
 import java.lang.reflect.AnnotatedType;
@@ -36,11 +43,26 @@ public class RangeLoader implements TypeLoader<Range> {
     public Range load(@NotNull AnnotatedType type, @NotNull Object o, @NotNull ConfigLoader configLoader, DepthTracker depthTracker)
     throws LoadException {
         if(o instanceof Map) {
-            Map<String, Integer> map = (Map<String, Integer>) o;
-            return new ConstantRange(map.get("min"), map.get("max"));
+            return configLoader.load(new RangeMapTemplate(), new MapConfiguration((Map<String, Object>) o), depthTracker).get();
         } else {
             int h = configLoader.loadType(Integer.class, o, depthTracker);
             return new ConstantRange(h, h + 1);
         }
     }
+    
+    /*
+     * Template needed so keys can be meta annotated, otherwise the loader could just grab keys directly from the object
+     */
+    public static class RangeMapTemplate implements ObjectTemplate<Range> {
+        @Value("min")
+        private @Meta int min;
+        
+        @Value("max")
+        private @Meta int max;
+        
+        @Override
+        public Range get() {
+            return new ConstantRange(min, max);
+        }
+    }
 }

common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/config/BufferedImageLoader.java

@@ -27,24 +27,43 @@ import javax.imageio.ImageIO;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
 import java.lang.reflect.AnnotatedType;
+import java.util.concurrent.ConcurrentHashMap;
 
+import com.dfsek.terra.api.config.ConfigPack;
 import com.dfsek.terra.api.config.Loader;
+import com.dfsek.terra.api.properties.Properties;
 
-
+/*
+ * @deprecated Use the Image and ImageLoader class provided by the library-image addon instead. This is subject to removal in v7.
+ */
+@Deprecated
 public class BufferedImageLoader implements TypeLoader<BufferedImage> {
     private final Loader files;
     
-    public BufferedImageLoader(Loader files) {
+    private final ConfigPack pack;
+    
+    public BufferedImageLoader(Loader files, ConfigPack pack) {
         this.files = files;
+        this.pack = pack;
+        if (!pack.getContext().has(ImageCache.class))
+            pack.getContext().put(new ImageCache(new ConcurrentHashMap<>()));
     }
     
     @Override
     public BufferedImage load(@NotNull AnnotatedType t, @NotNull Object c, @NotNull ConfigLoader loader, DepthTracker depthTracker)
     throws LoadException {
-        try {
-            return ImageIO.read(files.get((String) c));
-        } catch(IOException e) {
-            throw new LoadException("Unable to load image", e, depthTracker);
-        }
+        return pack.getContext().get(ImageCache.class).map.computeIfAbsent((String) c, s -> {
+            try {
+                return ImageIO.read(files.get(s));
+            } catch(IOException e) {
+                throw new LoadException("Unable to load image", e, depthTracker);
+            }
+        });
+    }
+    
+    /*
+     * Cache prevents configs from loading the same image multiple times into memory
+     */
+    private record ImageCache(ConcurrentHashMap<String, BufferedImage> map) implements Properties {
     }
 }

common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java

@@ -283,7 +283,7 @@ public class ConfigPackImpl implements ConfigPack {
     @Override
     public void register(TypeRegistry registry) {
         registry.registerLoader(ConfigType.class, configTypeRegistry)
-                .registerLoader(BufferedImage.class, new BufferedImageLoader(loader));
+                .registerLoader(BufferedImage.class, new BufferedImageLoader(loader, this));
         registryMap.forEach(registry::registerLoader);
         shortcuts.forEach(registry::registerLoader); // overwrite with delegated shortcuts if present
     }

common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java

@@ -68,7 +68,7 @@ public class MetaListLikePreprocessor extends MetaPreprocessor<Meta> {
                         
                         if(!(metaValue instanceof List)) {
                             throw new LoadException(
-                                    "MetaList/Set injection candidate must be list, is type " + metaValue.getClass().getCanonicalName(),
+                                    "Meta list / set injection (via <<) must point to a list. '" + meta + "' points to type " + metaValue.getClass().getCanonicalName(),
                                     depthTracker);
                         }