Persist and load terrain layers

commons/src/main/com/mbrlabs/mundus/commons/assets/TerrainAsset.java

@@ -21,12 +21,18 @@
 import com.badlogic.gdx.assets.AssetManager;
 import com.badlogic.gdx.files.FileHandle;
 import com.badlogic.gdx.math.Vector2;
+import com.badlogic.gdx.utils.Array;
 import com.mbrlabs.mundus.commons.assets.meta.Meta;
+import com.mbrlabs.mundus.commons.assets.meta.MetaTerrainLayer;
 import com.mbrlabs.mundus.commons.terrain.SplatMap;
 import com.mbrlabs.mundus.commons.terrain.SplatTexture;
 import com.mbrlabs.mundus.commons.terrain.Terrain;
 import com.mbrlabs.mundus.commons.terrain.TerrainLoader;
 import com.mbrlabs.mundus.commons.terrain.TerrainMaterial;
+import com.mbrlabs.mundus.commons.terrain.attributes.TerrainLayerAttribute;
+import com.mbrlabs.mundus.commons.terrain.layers.HeightTerrainLayer;
+import com.mbrlabs.mundus.commons.terrain.layers.SlopeTerrainLayer;
+import com.mbrlabs.mundus.commons.terrain.layers.TerrainLayer;
 
 import java.util.Map;
 
@@ -50,6 +56,8 @@ public class TerrainAsset extends Asset {
     private TextureAsset splatBNormal;
     private TextureAsset splatGNormal;
     private TextureAsset splatANormal;
+    private Array<TerrainLayer> heightLayers;
+    private Array<TerrainLayer> slopeLayers;
 
     private Terrain terrain;
 
@@ -304,6 +312,36 @@ public void resolveDependencies(Map<String, Asset> assets) {
         if (id != null && assets.containsKey(id)) {
             setSplatANormal((TextureAsset) assets.get(id));
         }
+
+        // Height layers
+        if (meta.getTerrain().getHeightLayers() != null) {
+            for (MetaTerrainLayer metaLayer : meta.getTerrain().getHeightLayers()) {
+                if (heightLayers == null) heightLayers = new Array<>();
+
+                TextureAsset texAsset = (TextureAsset) assets.get(metaLayer.getTextureAssetId());
+
+                HeightTerrainLayer terrainLayer = new HeightTerrainLayer(texAsset, metaLayer.getMinHeight(), metaLayer.getMaxHeight());
+                terrainLayer.setName(metaLayer.getName());
+                terrainLayer.active = metaLayer.isActive();
+
+                heightLayers.add(terrainLayer);
+            }
+        }
+
+        // Slope layers
+        if (meta.getTerrain().getSlopeLayers() != null) {
+            for (MetaTerrainLayer metaLayer : meta.getTerrain().getSlopeLayers()) {
+                if (slopeLayers == null) slopeLayers = new Array<>();
+
+                TextureAsset texAsset = (TextureAsset) assets.get(metaLayer.getTextureAssetId());
+
+                SlopeTerrainLayer terrainLayer = new SlopeTerrainLayer(texAsset, metaLayer.getMinHeight(), metaLayer.getMaxHeight(), metaLayer.getSlopeStrength());
+                terrainLayer.setName(metaLayer.getName());
+                terrainLayer.active = metaLayer.isActive();
+
+                slopeLayers.add(terrainLayer);
+            }
+        }
     }
 
     @Override
@@ -367,6 +405,22 @@ public void applyDependencies() {
             terrainMaterial.setSplatNormalTexture(new SplatTexture(SplatTexture.Channel.A, splatANormal));
         }
 
+        if (heightLayers == null) {
+            terrainMaterial.remove(TerrainLayerAttribute.HeightLayer);
+        } else {
+            TerrainLayerAttribute attr = new TerrainLayerAttribute(TerrainLayerAttribute.HeightLayer);
+            attr.terrainLayers.addAll(heightLayers);
+            terrainMaterial.set(attr);
+        }
+
+        if (slopeLayers == null) {
+            terrainMaterial.remove(TerrainLayerAttribute.SlopeLayer);
+        } else {
+            TerrainLayerAttribute attr = new TerrainLayerAttribute(TerrainLayerAttribute.SlopeLayer);
+            attr.terrainLayers.addAll(slopeLayers);
+            terrainMaterial.set(attr);
+        }
+
         terrain.update();
     }
 

commons/src/main/com/mbrlabs/mundus/commons/assets/meta/MetaLoader.java

@@ -17,6 +17,7 @@
 package com.mbrlabs.mundus.commons.assets.meta;
 
 import com.badlogic.gdx.files.FileHandle;
+import com.badlogic.gdx.utils.Array;
 import com.badlogic.gdx.utils.JsonReader;
 import com.badlogic.gdx.utils.JsonValue;
 import com.mbrlabs.mundus.commons.assets.AssetType;
@@ -74,9 +75,50 @@ private void parseTerrain(Meta meta, JsonValue jsonTerrain) {
         terrain.setSplatBNormal(jsonTerrain.getString(MetaTerrain.JSON_SPLAT_B_NORMAL, null));
         terrain.setSplatANormal(jsonTerrain.getString(MetaTerrain.JSON_SPLAT_A_NORMAL, null));
 
+        // Load Terrain Layers
+        Array<MetaTerrainLayer> hLayers = parseTerrainLayers(jsonTerrain.get(MetaTerrain.JSON_HEIGHT_LAYERS), false);
+        Array<MetaTerrainLayer> sLayers = parseTerrainLayers(jsonTerrain.get(MetaTerrain.JSON_SLOPE_LAYERS), true);
+        terrain.setHeightLayers(hLayers);
+        terrain.setSlopeLayers(sLayers);
+
         meta.setTerrain(terrain);
     }
 
+    /**
+     * Converts JsonValue Array of terrain layers into MetaTerrainLayer for
+     * loading the layer in the future.
+     */
+    private Array<MetaTerrainLayer> parseTerrainLayers(JsonValue layerArray, boolean isSlopeLayer) {
+        if (layerArray == null) return null;
+
+        Array<MetaTerrainLayer> layers = null;
+
+        // Get first layer of array
+        JsonValue child = layerArray.child;
+
+        while (child != null) {
+            if (layers == null) layers = new Array<>();
+
+            MetaTerrainLayer metaTerrainLayer = new MetaTerrainLayer();
+            metaTerrainLayer.setName(child.getString(MetaTerrain.JSON_HEIGHT_LAYER_NAME));
+            metaTerrainLayer.setActive(child.getBoolean(MetaTerrain.JSON_HEIGHT_LAYER_ACTIVE));
+            metaTerrainLayer.setTextureAssetId(child.getString(MetaTerrain.JSON_HEIGHT_LAYER_ASSET));
+            metaTerrainLayer.setMaxHeight(child.getFloat(MetaTerrain.JSON_HEIGHT_LAYER_MAX_HEIGHT));
+            metaTerrainLayer.setMinHeight(child.getFloat(MetaTerrain.JSON_HEIGHT_LAYER_MIN_HEIGHT));
+
+            if (isSlopeLayer) {
+                metaTerrainLayer.setSlopeStrength(child.getFloat(MetaTerrain.JSON_LAYER_SLOPE_STRENGTH));
+            }
+
+            layers.add(metaTerrainLayer);
+
+            // Get next array element
+            child = child.next();
+        }
+
+        return layers;
+    }
+
     private void parseModel(Meta meta, JsonValue jsonModel) {
         if(jsonModel == null) return;
 

commons/src/main/com/mbrlabs/mundus/commons/assets/meta/MetaTerrain.java

@@ -16,6 +16,8 @@
 
 package com.mbrlabs.mundus.commons.assets.meta;
 
+import com.badlogic.gdx.utils.Array;
+
 /**
  *
  * @author Marcus Brummer
@@ -38,6 +40,14 @@ public class MetaTerrain {
     public static final String JSON_SPLAT_B_NORMAL = "bNorm";
     public static final String JSON_SPLAT_A_NORMAL = "aNorm";
     public static final String JSON_UV_SCALE= "uv";
+    public static final String JSON_HEIGHT_LAYERS = "hLayers";
+    public static final String JSON_SLOPE_LAYERS = "sLayers";
+    public static final String JSON_HEIGHT_LAYER_ASSET = "asset";
+    public static final String JSON_HEIGHT_LAYER_ACTIVE = "active";
+    public static final String JSON_HEIGHT_LAYER_NAME = "name";
+    public static final String JSON_HEIGHT_LAYER_MIN_HEIGHT = "minH";
+    public static final String JSON_HEIGHT_LAYER_MAX_HEIGHT = "maxH";
+    public static final String JSON_LAYER_SLOPE_STRENGTH = "slopeStr";
 
     private int size;
     private int splatMapResolution;
@@ -54,6 +64,8 @@ public class MetaTerrain {
     private String splatGNormal;
     private String splatBNormal;
     private String splatANormal;
+    private Array<MetaTerrainLayer> heightLayers;
+    private Array<MetaTerrainLayer> slopeLayers;
 
     public String getSplatmap() {
         return splatmap;
@@ -175,6 +187,22 @@ public void setSplatANormal(String splatANormal) {
         this.splatANormal = splatANormal;
     }
 
+    public Array<MetaTerrainLayer> getHeightLayers() {
+        return heightLayers;
+    }
+
+    public void setHeightLayers(Array<MetaTerrainLayer> heightLayers) {
+        this.heightLayers = heightLayers;
+    }
+
+    public Array<MetaTerrainLayer> getSlopeLayers() {
+        return slopeLayers;
+    }
+
+    public void setSlopeLayers(Array<MetaTerrainLayer> slopeLayers) {
+        this.slopeLayers = slopeLayers;
+    }
+
     @Override
     public String toString() {
         return "MetaTerrain{" +

commons/src/main/com/mbrlabs/mundus/commons/assets/meta/MetaTerrainLayer.java

@@ -0,0 +1,63 @@
+package com.mbrlabs.mundus.commons.assets.meta;
+
+/**
+ * Simple POJO for the loading and saving of Terrain Layers
+ * @author JamesTKhan
+ * @version November 09, 2022
+ */
+public class MetaTerrainLayer {
+    private String name;
+    private String textureAssetId;
+    private boolean active;
+    private float minHeight;
+    private float maxHeight;
+    private float slopeStrength;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getTextureAssetId() {
+        return textureAssetId;
+    }
+
+    public void setTextureAssetId(String textureAssetId) {
+        this.textureAssetId = textureAssetId;
+    }
+
+    public boolean isActive() {
+        return active;
+    }
+
+    public void setActive(boolean active) {
+        this.active = active;
+    }
+
+    public float getMinHeight() {
+        return minHeight;
+    }
+
+    public void setMinHeight(float minHeight) {
+        this.minHeight = minHeight;
+    }
+
+    public float getMaxHeight() {
+        return maxHeight;
+    }
+
+    public void setMaxHeight(float maxHeight) {
+        this.maxHeight = maxHeight;
+    }
+
+    public float getSlopeStrength() {
+        return slopeStrength;
+    }
+
+    public void setSlopeStrength(float slopeStrength) {
+        this.slopeStrength = slopeStrength;
+    }
+}

editor/src/main/com/mbrlabs/mundus/editor/assets/EditorAssetManager.kt

@@ -37,8 +37,12 @@ import com.mbrlabs.mundus.commons.assets.TextureAsset
 import com.mbrlabs.mundus.commons.assets.WaterAsset
 import com.mbrlabs.mundus.commons.assets.meta.Meta
 import com.mbrlabs.mundus.commons.assets.meta.MetaTerrain
+import com.mbrlabs.mundus.commons.assets.meta.MetaTerrainLayer
 import com.mbrlabs.mundus.commons.scene3d.GameObject
 import com.mbrlabs.mundus.commons.scene3d.components.AssetUsage
+import com.mbrlabs.mundus.commons.terrain.attributes.TerrainLayerAttribute
+import com.mbrlabs.mundus.commons.terrain.layers.HeightTerrainLayer
+import com.mbrlabs.mundus.commons.terrain.layers.SlopeTerrainLayer
 import com.mbrlabs.mundus.commons.utils.FileFormatUtils
 import com.mbrlabs.mundus.commons.water.attributes.WaterColorAttribute
 import com.mbrlabs.mundus.commons.water.attributes.WaterFloatAttribute
@@ -686,10 +690,44 @@ class EditorAssetManager(assetsRoot: FileHandle) : AssetManager(assetsRoot) {
             terrain.meta.terrain.splatBase64 = "data:image/png;base64,$encoded"
         }
 
+        val heightAttr = terrain.terrain.terrainTexture.get(TerrainLayerAttribute.HeightLayer) as TerrainLayerAttribute?
+        val slopeAttr = terrain.terrain.terrainTexture.get(TerrainLayerAttribute.SlopeLayer) as TerrainLayerAttribute?
+
+        terrain.meta.terrain.heightLayers = getMetaTerrainLayers(heightAttr)
+        terrain.meta.terrain.slopeLayers = getMetaTerrainLayers(slopeAttr)
+
         // save meta file
         metaSaver.save(terrain.meta)
     }
 
+    /**
+     * Builds Array of MetaTerrainLayers for persisting Terrain Layers based on the given attribute
+     */
+    private fun getMetaTerrainLayers(attribute: TerrainLayerAttribute?): Array<MetaTerrainLayer>? {
+        if (attribute == null) return null
+
+        var arr : Array<MetaTerrainLayer>? = null
+
+        for (layer in attribute.terrainLayers) {
+            if (arr == null) arr = Array<MetaTerrainLayer>()
+
+            layer as HeightTerrainLayer
+            val metaLayer = MetaTerrainLayer()
+            metaLayer.isActive = layer.active
+            metaLayer.textureAssetId = layer.textureAsset.id
+            metaLayer.name = layer.name
+            metaLayer.maxHeight = layer.maxHeight
+            metaLayer.minHeight = layer.minHeight
+
+            if (layer is SlopeTerrainLayer) {
+                metaLayer.slopeStrength = layer.strength
+            }
+
+            arr.add(metaLayer)
+        }
+        return arr
+    }
+
     @Throws(IOException::class)
     fun saveMaterialAsset(mat: MaterialAsset) {
         // save .mat

editor/src/main/com/mbrlabs/mundus/editor/assets/MetaSaver.kt

@@ -16,12 +16,14 @@
 
 package com.mbrlabs.mundus.editor.assets
 
+import com.badlogic.gdx.utils.Array
 import com.badlogic.gdx.utils.Json
 import com.badlogic.gdx.utils.JsonWriter
 import com.mbrlabs.mundus.commons.assets.AssetType
 import com.mbrlabs.mundus.commons.assets.meta.Meta
 import com.mbrlabs.mundus.commons.assets.meta.MetaModel
 import com.mbrlabs.mundus.commons.assets.meta.MetaTerrain
+import com.mbrlabs.mundus.commons.assets.meta.MetaTerrainLayer
 
 /**
  *
@@ -88,7 +90,42 @@ class MetaSaver {
         if (terrain.splatGNormal != null) json.writeValue(MetaTerrain.JSON_SPLAT_G_NORMAL, terrain.splatGNormal)
         if (terrain.splatBNormal != null) json.writeValue(MetaTerrain.JSON_SPLAT_B_NORMAL, terrain.splatBNormal)
         if (terrain.splatANormal != null) json.writeValue(MetaTerrain.JSON_SPLAT_A_NORMAL, terrain.splatANormal)
+
+        // Convert layers
+        addTerrainLayer(json, terrain.heightLayers, false)
+        addTerrainLayer(json, terrain.slopeLayers, true)
+
         json.writeObjectEnd()
     }
 
+    /**
+     * Writes MetaTerrainLayers to the Meta Json object as arrays
+     */
+    private fun addTerrainLayer(json: Json, layers: Array<MetaTerrainLayer>?, isSlopeLayer: Boolean) {
+        if (layers == null || layers.isEmpty) return
+
+        if (isSlopeLayer) {
+            json.writeArrayStart(MetaTerrain.JSON_SLOPE_LAYERS)
+        } else {
+            json.writeArrayStart(MetaTerrain.JSON_HEIGHT_LAYERS)
+        }
+
+        for (i in 0 until layers.size) {
+            json.writeObjectStart()
+            val layer = layers.get(i) as MetaTerrainLayer
+            json.writeValue(MetaTerrain.JSON_HEIGHT_LAYER_NAME, layer.name)
+            json.writeValue(MetaTerrain.JSON_HEIGHT_LAYER_ACTIVE, layer.isActive)
+            json.writeValue(MetaTerrain.JSON_HEIGHT_LAYER_ASSET, layer.textureAssetId)
+            json.writeValue(MetaTerrain.JSON_HEIGHT_LAYER_MAX_HEIGHT, layer.maxHeight)
+            json.writeValue(MetaTerrain.JSON_HEIGHT_LAYER_MIN_HEIGHT, layer.minHeight)
+
+            if (isSlopeLayer) {
+                json.writeValue(MetaTerrain.JSON_LAYER_SLOPE_STRENGTH, layer.slopeStrength)
+            }
+
+            json.writeObjectEnd()
+        }
+        json.writeArrayEnd()
+    }
+
 }