ProcGen & Scene Static Upload Memory Optimizations

src/main/java/rs117/hd/HdPlugin.java

@@ -128,6 +128,7 @@
 import rs117.hd.utils.ResourcePath;
 import rs117.hd.utils.ShaderRecompile;
 import rs117.hd.utils.buffer.GLBuffer;
+import rs117.hd.utils.collections.PooledArrayType;
 import rs117.hd.utils.jobs.GenericJob;
 import rs117.hd.utils.jobs.JobSystem;
 
@@ -790,6 +791,7 @@ protected void shutDown() {
 			materialManager.shutDown();
 			textureManager.shutDown();
 
+			PooledArrayType.shutdown();
 			DestructibleHandler.flushPendingDestruction(true);
 
 			if (awtContext != null)

src/main/java/rs117/hd/overlays/FrameTimerOverlay.java

@@ -22,6 +22,7 @@
 import rs117.hd.renderer.zone.ZoneRenderer;
 import rs117.hd.utils.FrameTimingsRecorder;
 import rs117.hd.utils.NpcDisplacementCache;
+import rs117.hd.utils.collections.PooledArrayType;
 import rs117.hd.utils.jobs.JobSystem;
 
 import static rs117.hd.renderer.zone.SceneManager.MAX_WORLDVIEWS;
@@ -151,6 +152,11 @@ public Dimension render(Graphics2D g) {
 				.right(format("%d ns", frameTimer.errorCompensation))
 				.build());
 
+			children.add(LineComponent.builder()
+				.left("Pooled Array Size:")
+				.right(formatBytes(PooledArrayType.getCurrentTotalCacheSize()))
+				.build());
+
 			children.add(LineComponent.builder()
 				.left("Garbage collection count:")
 				.right(String.valueOf(plugin.getGarbageCollectionCount()))

src/main/java/rs117/hd/renderer/legacy/LegacyModelPusher.java

@@ -72,6 +72,7 @@ public class LegacyModelPusher {
 
 	private static final int[] ZEROED_INTS = new int[12];
 
+	private final int[] tzHaarRecolored = new int[3];
 	private ModelCache modelCache;
 
 	public void startUp() {
@@ -387,7 +388,7 @@ public void pushModel(
 		sceneContext.modelPusherResults[1] = texturedFaceCount;
 	}
 
-	private void getNormalDataForFace(SceneContext sceneContext, Model model, @Nonnull ModelOverride modelOverride, int face) {
+	private void getNormalDataForFace(LegacySceneContext sceneContext, Model model, @Nonnull ModelOverride modelOverride, int face) {
 		assert packTerrainData(false, 0, WaterType.NONE, 0) == 0;
 		if (modelOverride.flatNormals || !plugin.configPreserveVanillaNormals && model.getFaceColors3()[face] == -1) {
 			Arrays.fill(sceneContext.modelFaceNormals, 0);
@@ -424,7 +425,7 @@ private void getNormalDataForFace(SceneContext sceneContext, Model model, @Nonnu
 
 	@SuppressWarnings({ "ReassignedVariable" })
 	private int[] getFaceVertices(
-		SceneContext sceneContext,
+		LegacySceneContext sceneContext,
 		Tile tile,
 		int uuid,
 		Model model,
@@ -587,13 +588,14 @@ private int[] getFaceVertices(
 				}
 
 				if (plugin.configLegacyTzHaarReskin && modelOverride.tzHaarRecolorType != TzHaarRecolorType.NONE) {
-					int[] tzHaarRecolored = ProceduralGenerator.recolorTzHaar(
+					ProceduralGenerator.recolorTzHaar(
 						modelOverride,
 						model,
 						face,
 						color1,
 						color2,
-						color3
+						color3,
+						tzHaarRecolored
 					);
 					color1 = tzHaarRecolored[0];
 					color2 = tzHaarRecolored[1];

src/main/java/rs117/hd/renderer/legacy/LegacySceneContext.java

@@ -6,6 +6,7 @@
 import rs117.hd.utils.buffer.GpuFloatBuffer;
 import rs117.hd.utils.buffer.GpuIntBuffer;
 
+import static net.runelite.api.Constants.*;
 import static rs117.hd.utils.MathUtils.*;
 
 public class LegacySceneContext extends SceneContext {
@@ -14,11 +15,28 @@ public class LegacySceneContext extends SceneContext {
 	public boolean isPrepared;
 	public boolean forceDisableAreaHiding;
 
+	public byte[][][] underwaterDepthLevels;
+
 	public GpuIntBuffer staticUnorderedModelBuffer;
 	public GpuIntBuffer stagingBufferVertices;
 	public GpuFloatBuffer stagingBufferUvs;
 	public GpuFloatBuffer stagingBufferNormals;
 
+	public int staticVertexCount = 0;
+	public int staticGapFillerTilesOffset;
+	public int staticGapFillerTilesVertexCount;
+	public int staticCustomTilesOffset;
+	public int staticCustomTilesVertexCount;
+
+	// Statistics
+	public int uniqueModels;
+
+	// Model pusher arrays, to avoid simultaneous usage from different threads
+	public final int[] modelFaceVertices = new int[12];
+	public final float[] modelFaceUvs = new float[12];
+	public final float[] modelFaceNormals = new float[12];
+	public final int[] modelPusherResults = new int[2];
+
 	public LegacySceneContext(
 		Client client,
 		Scene scene,
@@ -27,6 +45,8 @@ public LegacySceneContext(
 	) {
 		super(client, scene, expandedMapLoadingChunks);
 
+		underwaterDepthLevels = new byte[MAX_Z][EXTENDED_SCENE_SIZE][EXTENDED_SCENE_SIZE];
+
 		if (previous == null) {
 			staticUnorderedModelBuffer = new GpuIntBuffer();
 			stagingBufferVertices = new GpuIntBuffer();

src/main/java/rs117/hd/renderer/legacy/LegacySceneUploader.java

@@ -54,6 +54,8 @@
 import static net.runelite.api.Constants.*;
 import static net.runelite.api.Constants.SCENE_SIZE;
 import static net.runelite.api.Perspective.*;
+import static rs117.hd.scene.SceneContext.TILE_SKIP_FLAG;
+import static rs117.hd.scene.SceneContext.TILE_WATER_FLAG;
 import static rs117.hd.scene.tile_overrides.TileOverride.NONE;
 import static rs117.hd.scene.tile_overrides.TileOverride.OVERLAY_FLAG;
 import static rs117.hd.utils.HDUtils.HIDDEN_HSL;
@@ -68,7 +70,7 @@ public class LegacySceneUploader {
 	public static final int SCENE_ID_MASK = 0xFFFF;
 	public static final int EXCLUDED_FROM_SCENE_BUFFER = 0xFFFFFFFF;
 
-	private static final int[] UP_NORMAL = { 0, -1, 0 };
+	private static final short[] UP_NORMAL = { 0, -1, 0 };
 
 	@Inject
 	private Client client;
@@ -98,7 +100,7 @@ public class LegacySceneUploader {
 	private LegacyModelPusher modelPusher;
 
 	public void upload(LegacySceneContext sceneContext) {
-		proceduralGenerator.generateSceneData(sceneContext);
+		proceduralGenerator.generateSceneData(sceneContext, null);
 
 		Stopwatch stopwatch = Stopwatch.createStarted();
 
@@ -643,10 +645,10 @@ private int[] uploadHDTilePaintSurface(
 			Material neMaterial = Material.NONE;
 			Material nwMaterial = Material.NONE;
 
-			int[] swNormals = UP_NORMAL;
-			int[] seNormals = UP_NORMAL;
-			int[] neNormals = UP_NORMAL;
-			int[] nwNormals = UP_NORMAL;
+			short[] swNormals = UP_NORMAL;
+			short[] seNormals = UP_NORMAL;
+			short[] neNormals = UP_NORMAL;
+			short[] nwNormals = UP_NORMAL;
 
 			if (waterType == WaterType.NONE) {
 				if (textureId != -1) {
@@ -657,10 +659,10 @@ private int[] uploadHDTilePaintSurface(
 					swMaterial = seMaterial = neMaterial = nwMaterial = material;
 				}
 
-				swNormals = sceneContext.vertexTerrainNormals.getOrDefault(swVertexKey, swNormals);
-				seNormals = sceneContext.vertexTerrainNormals.getOrDefault(seVertexKey, seNormals);
-				neNormals = sceneContext.vertexTerrainNormals.getOrDefault(neVertexKey, neNormals);
-				nwNormals = sceneContext.vertexTerrainNormals.getOrDefault(nwVertexKey, nwNormals);
+				swNormals = sceneContext.getVertexNormalOrDefault(swVertexKey, new short[3], UP_NORMAL);
+				seNormals = sceneContext.getVertexNormalOrDefault(seVertexKey, new short[3], UP_NORMAL);
+				neNormals = sceneContext.getVertexNormalOrDefault(neVertexKey, new short[3], UP_NORMAL);
+				nwNormals = sceneContext.getVertexNormalOrDefault(nwVertexKey, new short[3], UP_NORMAL);
 
 				boolean useBlendedMaterialAndColor =
 					plugin.configGroundBlending &&
@@ -707,23 +709,23 @@ private int[] uploadHDTilePaintSurface(
 				// set colors for the shoreline to create a foam effect in the water shader
 				swColor = seColor = nwColor = neColor = 127;
 
-				if (sceneContext.vertexIsWater.containsKey(swVertexKey) && sceneContext.vertexIsLand.containsKey(swVertexKey))
+				if (sceneContext.isVertexWater(swVertexKey) && sceneContext.isVertexLand(swVertexKey))
 					swColor = 0;
-				if (sceneContext.vertexIsWater.containsKey(seVertexKey) && sceneContext.vertexIsLand.containsKey(seVertexKey))
+				if (sceneContext.isVertexWater(seVertexKey) && sceneContext.isVertexLand(seVertexKey))
 					seColor = 0;
-				if (sceneContext.vertexIsWater.containsKey(nwVertexKey) && sceneContext.vertexIsLand.containsKey(nwVertexKey))
+				if (sceneContext.isVertexWater(nwVertexKey) && sceneContext.isVertexLand(nwVertexKey))
 					nwColor = 0;
-				if (sceneContext.vertexIsWater.containsKey(neVertexKey) && sceneContext.vertexIsLand.containsKey(neVertexKey))
+				if (sceneContext.isVertexWater(neVertexKey) && sceneContext.isVertexLand(neVertexKey))
 					neColor = 0;
 			}
 
-			if (sceneContext.vertexIsOverlay.containsKey(neVertexKey) && sceneContext.vertexIsUnderlay.containsKey(neVertexKey))
+			if (sceneContext.isVertexOverlay(neVertexKey) && sceneContext.isVertexUnderlay(neVertexKey))
 				neVertexIsOverlay = true;
-			if (sceneContext.vertexIsOverlay.containsKey(nwVertexKey) && sceneContext.vertexIsUnderlay.containsKey(nwVertexKey))
+			if (sceneContext.isVertexOverlay(nwVertexKey) && sceneContext.isVertexUnderlay(nwVertexKey))
 				nwVertexIsOverlay = true;
-			if (sceneContext.vertexIsOverlay.containsKey(seVertexKey) && sceneContext.vertexIsUnderlay.containsKey(seVertexKey))
+			if (sceneContext.isVertexOverlay(seVertexKey) && sceneContext.isVertexUnderlay(seVertexKey))
 				seVertexIsOverlay = true;
-			if (sceneContext.vertexIsOverlay.containsKey(swVertexKey) && sceneContext.vertexIsUnderlay.containsKey(swVertexKey))
+			if (sceneContext.isVertexOverlay(swVertexKey) && sceneContext.isVertexUnderlay(swVertexKey))
 				swVertexIsOverlay = true;
 
 			swHeight -= override.heightOffset;
@@ -829,23 +831,23 @@ private int[] uploadHDTilePaintUnderwater(LegacySceneContext sceneContext, Tile
 		int nwVertexKey = vertexKeys[2];
 		int neVertexKey = vertexKeys[3];
 
-		if (sceneContext.tileIsWater[tileZ][tileExX][tileExY]) {
+		if (sceneContext.isTileFlagSet(tileZ, tileExX, tileExY, TILE_WATER_FLAG)) {
 			// underwater terrain
 
 			underwaterTerrain = 1;
 
 			int swColor, seColor, neColor, nwColor;
 			swColor = seColor = neColor = nwColor = UNDERWATER_HSL;
 
-			int swDepth = sceneContext.vertexUnderwaterDepth.getOrDefault(swVertexKey, 0);
-			int seDepth = sceneContext.vertexUnderwaterDepth.getOrDefault(seVertexKey, 0);
-			int nwDepth = sceneContext.vertexUnderwaterDepth.getOrDefault(nwVertexKey, 0);
-			int neDepth = sceneContext.vertexUnderwaterDepth.getOrDefault(neVertexKey, 0);
+			int swDepth = sceneContext.getVertexUnderwaterDepth(swVertexKey);
+			int seDepth = sceneContext.getVertexUnderwaterDepth(seVertexKey);
+			int nwDepth = sceneContext.getVertexUnderwaterDepth(nwVertexKey);
+			int neDepth = sceneContext.getVertexUnderwaterDepth(neVertexKey);
 
-			int[] swNormals = sceneContext.vertexTerrainNormals.getOrDefault(swVertexKey, UP_NORMAL);
-			int[] seNormals = sceneContext.vertexTerrainNormals.getOrDefault(seVertexKey, UP_NORMAL);
-			int[] nwNormals = sceneContext.vertexTerrainNormals.getOrDefault(nwVertexKey, UP_NORMAL);
-			int[] neNormals = sceneContext.vertexTerrainNormals.getOrDefault(neVertexKey, UP_NORMAL);
+			short[] swNormals = sceneContext.getVertexNormalOrDefault(swVertexKey, new short[3], UP_NORMAL);
+			short[] seNormals = sceneContext.getVertexNormalOrDefault(seVertexKey, new short[3], UP_NORMAL);
+			short[] nwNormals = sceneContext.getVertexNormalOrDefault(nwVertexKey, new short[3], UP_NORMAL);
+			short[] neNormals = sceneContext.getVertexNormalOrDefault(neVertexKey, new short[3], UP_NORMAL);
 
 			Material swMaterial = Material.NONE;
 			Material seMaterial = Material.NONE;
@@ -943,7 +945,7 @@ private int[] uploadHDTileModelSurface(
 		final int tileExY = tileY + sceneContext.sceneOffset;
 		final int tileZ = tile.getRenderLevel();
 
-		if (!fillGaps && sceneContext.skipTile[tileZ][tileExX][tileExY])
+		if (!fillGaps && sceneContext.isTileFlagSet(tileZ, tileExX, tileExY, TILE_SKIP_FLAG))
 			return new int[3];
 
 		int bufferLength = 0;
@@ -985,9 +987,9 @@ private int[] uploadHDTileModelSurface(
 			int uvOrientation = 0;
 			float uvScale = 1;
 
-			int[] normalsA = UP_NORMAL;
-			int[] normalsB = UP_NORMAL;
-			int[] normalsC = UP_NORMAL;
+			short[] normalsA = UP_NORMAL;
+			short[] normalsB = UP_NORMAL;
+			short[] normalsC = UP_NORMAL;
 
 			WaterType waterType = WaterType.NONE;
 
@@ -1013,9 +1015,9 @@ private int[] uploadHDTileModelSurface(
 						materialA = materialB = materialC = material;
 					}
 
-					normalsA = sceneContext.vertexTerrainNormals.getOrDefault(vertexKeyA, normalsA);
-					normalsB = sceneContext.vertexTerrainNormals.getOrDefault(vertexKeyB, normalsB);
-					normalsC = sceneContext.vertexTerrainNormals.getOrDefault(vertexKeyC, normalsC);
+					normalsA = sceneContext.getVertexNormalOrDefault(vertexKeyA, new short[3], UP_NORMAL);
+					normalsB = sceneContext.getVertexNormalOrDefault(vertexKeyB, new short[3], UP_NORMAL);
+					normalsC = sceneContext.getVertexNormalOrDefault(vertexKeyC, new short[3], UP_NORMAL);
 
 					GroundMaterial groundMaterial = null;
 
@@ -1068,19 +1070,19 @@ private int[] uploadHDTileModelSurface(
 				} else {
 					// set colors for the shoreline to create a foam effect in the water shader
 					colorA = colorB = colorC = 127;
-					if (sceneContext.vertexIsWater.containsKey(vertexKeyA) && sceneContext.vertexIsLand.containsKey(vertexKeyA))
+					if (sceneContext.isVertexWater(vertexKeyA) && sceneContext.isVertexLand(vertexKeyA))
 						colorA = 0;
-					if (sceneContext.vertexIsWater.containsKey(vertexKeyB) && sceneContext.vertexIsLand.containsKey(vertexKeyB))
+					if (sceneContext.isVertexWater(vertexKeyB) && sceneContext.isVertexLand(vertexKeyB))
 						colorB = 0;
-					if (sceneContext.vertexIsWater.containsKey(vertexKeyC) && sceneContext.vertexIsLand.containsKey(vertexKeyC))
+					if (sceneContext.isVertexWater(vertexKeyC) && sceneContext.isVertexLand(vertexKeyC))
 						colorC = 0;
 				}
 
-				if (sceneContext.vertexIsOverlay.containsKey(vertexKeyA) && sceneContext.vertexIsUnderlay.containsKey(vertexKeyA))
+				if (sceneContext.isVertexOverlay(vertexKeyA) && sceneContext.isVertexUnderlay(vertexKeyA))
 					vertexAIsOverlay = true;
-				if (sceneContext.vertexIsOverlay.containsKey(vertexKeyB) && sceneContext.vertexIsUnderlay.containsKey(vertexKeyB))
+				if (sceneContext.isVertexOverlay(vertexKeyB) && sceneContext.isVertexUnderlay(vertexKeyB))
 					vertexBIsOverlay = true;
-				if (sceneContext.vertexIsOverlay.containsKey(vertexKeyC) && sceneContext.vertexIsUnderlay.containsKey(vertexKeyC))
+				if (sceneContext.isVertexOverlay(vertexKeyC) && sceneContext.isVertexUnderlay(vertexKeyC))
 					vertexCIsOverlay = true;
 
 				for (int i = 0; i < 3; i++)
@@ -1144,7 +1146,7 @@ private int[] uploadHDTileModelUnderwater(LegacySceneContext sceneContext, Tile
 		int uvBufferLength = 0;
 		int underwaterTerrain = 0;
 
-		if (sceneContext.skipTile[tileZ][tileExX][tileExY])
+		if (sceneContext.isTileFlagSet(tileZ, tileExX, tileExY, TILE_SKIP_FLAG))
 			return new int[] { bufferLength, uvBufferLength, underwaterTerrain };
 
 		final int[] faceColorA = model.getTriangleColorA();
@@ -1159,7 +1161,7 @@ private int[] uploadHDTileModelUnderwater(LegacySceneContext sceneContext, Tile
 			return new int[] { bufferLength, uvBufferLength, underwaterTerrain };
 		}
 
-		if (sceneContext.tileIsWater[tileZ][tileExX][tileExY]) {
+		if (sceneContext.isTileFlagSet(tileZ, tileExX, tileExY, TILE_WATER_FLAG)) {
 			underwaterTerrain = 1;
 
 			int overlayId = OVERLAY_FLAG | scene.getOverlayIds()[tileZ][tileExX][tileExY];
@@ -1188,9 +1190,9 @@ private int[] uploadHDTileModelUnderwater(LegacySceneContext sceneContext, Tile
 				int vertexKeyB = vertexKeys[1];
 				int vertexKeyC = vertexKeys[2];
 
-				int depthA = sceneContext.vertexUnderwaterDepth.getOrDefault(vertexKeyA, 0);
-				int depthB = sceneContext.vertexUnderwaterDepth.getOrDefault(vertexKeyB, 0);
-				int depthC = sceneContext.vertexUnderwaterDepth.getOrDefault(vertexKeyC, 0);
+				int depthA = sceneContext.getVertexUnderwaterDepth(vertexKeyA);
+				int depthB = sceneContext.getVertexUnderwaterDepth(vertexKeyB);
+				int depthC = sceneContext.getVertexUnderwaterDepth(vertexKeyC);
 
 				if (plugin.configGroundTextures) {
 					GroundMaterial groundMaterial = GroundMaterial.UNDERWATER_GENERIC;
@@ -1211,9 +1213,9 @@ private int[] uploadHDTileModelUnderwater(LegacySceneContext sceneContext, Tile
 					);
 				}
 
-				int[] normalsA = sceneContext.vertexTerrainNormals.getOrDefault(vertexKeyA, UP_NORMAL);
-				int[] normalsB = sceneContext.vertexTerrainNormals.getOrDefault(vertexKeyB, UP_NORMAL);
-				int[] normalsC = sceneContext.vertexTerrainNormals.getOrDefault(vertexKeyC, UP_NORMAL);
+				short[] normalsA = sceneContext.getVertexNormalOrDefault(vertexKeyA, new short[3], UP_NORMAL);
+				short[] normalsB = sceneContext.getVertexNormalOrDefault(vertexKeyB, new short[3], UP_NORMAL);
+				short[] normalsC = sceneContext.getVertexNormalOrDefault(vertexKeyC, new short[3], UP_NORMAL);
 
 				int textureId = faceTextures == null ? -1 : faceTextures[face];
 				WaterType waterType = proceduralGenerator.seasonalWaterType(override, textureId);