LargePalette: avoid paying upfront performance penalty for cache population

This made the creation of large palettes 100x slower.

By harnessing the scans that we would've done on writes previously
anyway, we can lazily populate the map when the element isn't found
in the map. Performance of write is therefore no worse than previous
for the first write, and for subsequent ones will always be faster.

Since many palettes go their entire lifespan without being modified,
it doesn't make much sense to pay an up-front performance penalty.

Author: dktapps

lib/Palette.h

@@ -99,14 +99,12 @@ class LargePalette final {
 private:
 	std::vector<Block> palette;
 	std::unordered_map<Block, unsigned int> blockToOffset;
+	unsigned int lowestUnscanned = 0;
 
 	void initFromData(const gsl::span<const Block> paletteEntries) {
 		PaletteUtils<MAX_PALETTE_SIZE>::checkSize(paletteEntries.size());
 
 		palette = std::vector<Block>(paletteEntries.begin(), paletteEntries.end());
-		for (unsigned int i = 0; i < palette.size(); ++i) {
-			blockToOffset[palette[i]] = i;
-		}
 	}
 
 public:
@@ -150,6 +148,21 @@ class LargePalette final {
 			return it->second;
 		}
 
+		//Lookup map is lazily populated to avoid a performance penalty on data load
+		//Since it's possible for an array to go its whole lifespan without any writes,
+		//there's little sense paying a performance penalty on load to pre-populate it
+		//Previously we would've had to do a scan like this anyway, but with the offset
+		//map cache we can get more mileage out of it by avoiding such large scans on
+		//subsequent writes
+		for (unsigned int offset = lowestUnscanned; offset < palette.size(); ++offset) {
+			blockToOffset[palette[offset]] = offset;
+			if (palette[offset] == val) {
+				lowestUnscanned = offset + 1;
+				return offset;
+			}
+		}
+		lowestUnscanned = palette.size();
+
 		if (palette.size() >= MAX_PALETTE_SIZE) {
 			return -1;
 		}