Tinker with performance on some base data classes

mikeprimm · mikeprimm · commit c6fb0be7e7c0 · 2026-03-05T18:45:42.000-05:00
diff --git a/DynmapCore/src/main/java/org/dynmap/Color.java b/DynmapCore/src/main/java/org/dynmap/Color.java
@@ -38,12 +38,13 @@ public final void setTransparent() {
         val = TRANSPARENT;
     }
     public final void setGrayscale() {
-        int alpha = (val >> 24) & 0xFF;
-        int red = (val >> 16) & 0xFF;
-        int green = (val >> 8) & 0xFF;
-        int blue = val & 0xFF;
-        int gray = ((red * 76) + (green * 151) + (blue * 28)) / 255;
-        setRGBA(gray, gray, gray, alpha);
+        int alpha = val & 0xFF000000;
+        int num = (((val >> 16) & 0xFF) * 76)
+                + (((val >> 8)  & 0xFF) * 151)
+                + (( val        & 0xFF) * 28);
+        // weights sum to 255, so num ∈ [0, 65025]; fast /255 via shift
+        int gray = (num + (num >> 8) + 1) >> 8;
+        val = alpha | (gray << 16) | (gray << 8) | gray;
     }
     public final void setColor(Color c) {
         val = c.val;
@@ -85,11 +86,10 @@ public final void blendColor(Color c) {
      * @param argb - ARGB to blend
      */
     public final void blendColor(int argb) {
-        int nval = (((((val >> 24) & 0xFF) * ((argb >> 24) & 0xFF)) / 255) << 24);
-        nval = nval | (((((val >> 16) & 0xFF) * ((argb >> 16) & 0xFF)) / 255) << 16);
-        nval = nval | (((((val >> 8) & 0xFF) * ((argb >> 8) & 0xFF)) / 255) << 8);
-        nval = nval | (((val & 0xFF) * (argb & 0xFF)) / 255);
-        val = nval;
+        val = (mulDiv255(val >>> 24,         argb >>> 24        ) << 24)
+            | (mulDiv255((val >> 16) & 0xFF, (argb >> 16) & 0xFF) << 16)
+            | (mulDiv255((val >> 8)  & 0xFF, (argb >> 8)  & 0xFF) << 8)
+            |  mulDiv255( val        & 0xFF,  argb        & 0xFF);
     }
     /**
      * Scale each color component, based on the corresponding component
@@ -98,10 +98,30 @@ public final void blendColor(int argb) {
      * @return blended color
      */
     public static final int blendColor(int argb0, int argb1) {
-        int nval = (((((argb0 >> 24) & 0xFF) * ((argb1 >> 24) & 0xFF)) / 255) << 24);
-        nval = nval | (((((argb0 >> 16) & 0xFF) * ((argb1 >> 16) & 0xFF)) / 255) << 16);
-        nval = nval | (((((argb0 >> 8) & 0xFF) * ((argb1 >> 8) & 0xFF)) / 255) << 8);
-        nval = nval | (((argb0 & 0xFF) * (argb1 & 0xFF)) / 255);
-        return nval;
+        return (mulDiv255(argb0 >>> 24,          argb1 >>> 24        ) << 24)
+             | (mulDiv255((argb0 >> 16) & 0xFF,  (argb1 >> 16) & 0xFF) << 16)
+             | (mulDiv255((argb0 >> 8)  & 0xFF,  (argb1 >> 8)  & 0xFF) << 8)
+             |  mulDiv255( argb0        & 0xFF,   argb1        & 0xFF);
+    }
+    /**
+     * Scale the RGB channels by scale/256, leaving alpha unchanged.
+     * Equivalent to setRGBA(getRed()*scale>>8, getGreen()*scale>>8, getBlue()*scale>>8, getAlpha())
+     * but avoids redundant unpack/repack of the alpha channel.
+     * @param scale - scale factor 0..256 (256 = full brightness)
+     */
+    public final void scaleRGB(int scale) {
+        val = (val & 0xFF000000)
+            | ((((val >> 16) & 0xFF) * scale >> 8) << 16)
+            | ((((val >> 8)  & 0xFF) * scale >> 8) << 8)
+            |  ((val         & 0xFF) * scale >> 8);
+    }
+    /**
+     * Fast multiply-then-divide-by-255 for two values a, b each in [0, 255].
+     * Returns floor(a*b/255), equivalent to the standard integer division but
+     * computed with shifts only: (x + (x >> 8) + 1) >> 8 where x = a * b.
+     */
+    private static int mulDiv255(int a, int b) {
+        int x = a * b;
+        return (x + (x >> 8) + 1) >> 8;
     }
 }
diff --git a/DynmapCore/src/main/java/org/dynmap/common/BiomeMap.java b/DynmapCore/src/main/java/org/dynmap/common/BiomeMap.java
@@ -2,6 +2,7 @@
 
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Optional;
 
@@ -11,7 +12,9 @@
 public class BiomeMap {
 	public static final int NO_INDEX = -2;
     private static BiomeMap[] biome_by_index = new BiomeMap[256];
-    private static Map<String, BiomeMap> biome_by_rl = new HashMap<String, BiomeMap>();
+    private static Map<String, BiomeMap> biome_by_rl = new HashMap<String, BiomeMap>(256);
+    // Tracks registered IDs for O(1) uniqueness checks during initialization
+    private static final HashSet<String> biome_ids = new HashSet<String>(256);
     public static final BiomeMap NULL = new BiomeMap(-1, "NULL", 0.5, 0.5, 0xFFFFFF, 0, 0, null);
 
     public static final BiomeMap OCEAN = new BiomeMap(0, "OCEAN", "minecraft:ocean");
@@ -145,12 +148,17 @@ public static void loadWellKnownByVersion(String mcver) {
     }
 
     private static boolean isUniqueID(String id) {
-        for(int i = 0; i < biome_by_index.length; i++) {
-            if(biome_by_index[i] == null) continue;
-            if(biome_by_index[i].id.equals(id))
-                return false;
-        }
-        return true;
+        return !biome_ids.contains(id);
+    }
+
+    /**
+     * Encodes a grass/foliage color multiplier for efficient hot-path dispatch:
+     *   == 0              → 0 (passthrough: return raw value unchanged)
+     *   0 < val ≤ 0xFFFFFF → positive (blend: average with raw)
+     *   val > 0xFFFFFF    → -(val & 0xFFFFFF) (negative sentinel: fixed override color)
+     */
+    private static int encodeColorMult(int val) {
+        return (val > 0xFFFFFF) ? -(val & 0xFFFFFF) : val;
     }
     
     private static void resizeIfNeeded(int idx) {
@@ -171,15 +179,16 @@ private BiomeMap(int idx, String id, double tmp, double rain, int waterColorMult
         setTemperature(tmp);
         setRainfall(rain);
         this.watercolormult = waterColorMultiplier;
-        this.grassmult = grassmult;
-        this.foliagemult = foliagemult;
+        this.grassmult = encodeColorMult(grassmult);
+        this.foliagemult = encodeColorMult(foliagemult);
         // Handle null biome
         if (id == null) { id = "biome_" + idx; }
         id = id.toUpperCase().replace(' ', '_');
         if (isUniqueID(id) == false) {
             id = id + "_" + idx;
         }
         this.id = id;
+        biome_ids.add(this.id);
         // If index is NO_INDEX, find one after the well known ones
         if (idx == NO_INDEX) {
         	idx = LAST_WELL_KNOWN;
@@ -235,21 +244,15 @@ public final int biomeLookup() {
     }
     
     public final int getModifiedGrassMultiplier(int rawgrassmult) {
-        if(grassmult == 0)
-            return rawgrassmult;
-        else if(grassmult > 0xFFFFFF)
-            return grassmult & 0xFFFFFF;
-        else
-            return ((rawgrassmult & 0xfefefe) + grassmult) / 2;
+        if (grassmult == 0) return rawgrassmult;          // common case: no override
+        if (grassmult < 0) return -grassmult;             // fixed color (pre-masked at set-time)
+        return ((rawgrassmult & 0xfefefe) + grassmult) >> 1;  // blend
     }
-    
+
     public final int getModifiedFoliageMultiplier(int rawfoliagemult) {
-        if(foliagemult == 0)
-            return rawfoliagemult;
-        else if(foliagemult > 0xFFFFFF)
-            return foliagemult & 0xFFFFFF;
-        else
-            return ((rawfoliagemult & 0xfefefe) + foliagemult) / 2;
+        if (foliagemult == 0) return rawfoliagemult;       // common case: no override
+        if (foliagemult < 0) return -foliagemult;          // fixed color (pre-masked at set-time)
+        return ((rawfoliagemult & 0xfefefe) + foliagemult) >> 1;  // blend
     }
     public final int getWaterColorMult() {
         return watercolormult;
@@ -278,10 +281,10 @@ public void setWaterColorMultiplier(int watercolormult) {
         this.watercolormult = watercolormult;
     }
     public void setGrassColorMultiplier(int grassmult) {
-        this.grassmult = grassmult;
+        this.grassmult = encodeColorMult(grassmult);
     }
     public void setFoliageColorMultiplier(int foliagemult) {
-        this.foliagemult = foliagemult;
+        this.foliagemult = encodeColorMult(foliagemult);
     }
     public void setTemperature(double tmp) {
         if(tmp < 0.0) tmp = 0.0;
diff --git a/DynmapCore/src/main/java/org/dynmap/common/chunk/GenericChunk.java b/DynmapCore/src/main/java/org/dynmap/common/chunk/GenericChunk.java
@@ -38,7 +38,7 @@ private GenericChunk(int cx, int cz, int cy_min, GenericChunkSection[] sections,
 	// Get section for given block Y coord
 	public final GenericChunkSection getSection(int y) {
 		int idx = (y >> 4) - this.cy_min;
-		if ((idx < 0) || (idx >= sectionCnt)) {
+		if ((idx < 0) || (idx >= sections.length)) {
 			return GenericChunkSection.EMPTY;
 		}
 		return this.sections[idx];
diff --git a/DynmapCore/src/main/java/org/dynmap/common/chunk/GenericChunkCache.java b/DynmapCore/src/main/java/org/dynmap/common/chunk/GenericChunkCache.java
@@ -4,13 +4,14 @@
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
 import java.lang.ref.SoftReference;
+import java.util.HashMap;
 import java.util.IdentityHashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
 import org.dynmap.utils.DynIntHashMap;
 
-// Generic chunk cache 
+// Generic chunk cache
 public class GenericChunkCache {
     public static class ChunkCacheRec {
         public GenericChunk ss;
@@ -23,22 +24,26 @@ public static class ChunkCacheRec {
     private long cache_attempts;
     private long cache_success;
     private boolean softref;
+    // World name -> small integer ID, used to build long cache keys without String concatenation.
+    // Accessed only while holding snapcachelock.
+    private final HashMap<String, Integer> worldIds = new HashMap<String, Integer>();
+    private int nextWorldId = 0;
 
     private static class CacheRec {
         Reference<ChunkCacheRec> ref;
     }
-    
+
     @SuppressWarnings("serial")
-    public class CacheHashMap extends LinkedHashMap<String, CacheRec> {
+    public class CacheHashMap extends LinkedHashMap<Long, CacheRec> {
         private int limit;
-        private IdentityHashMap<Reference<ChunkCacheRec>, String> reverselookup;
+        private IdentityHashMap<Reference<ChunkCacheRec>, Long> reverselookup;
 
         public CacheHashMap(int lim) {
             super(16, (float)0.75, true);
             limit = lim;
-            reverselookup = new IdentityHashMap<Reference<ChunkCacheRec>, String>();
+            reverselookup = new IdentityHashMap<Reference<ChunkCacheRec>, Long>();
         }
-        protected boolean removeEldestEntry(Map.Entry<String, CacheRec> last) {
+        protected boolean removeEldestEntry(Map.Entry<Long, CacheRec> last) {
             boolean remove = (size() >= limit);
             if(remove && (last != null) && (last.getValue() != null)) {
                 reverselookup.remove(last.getValue().ref);
@@ -56,15 +61,26 @@ public GenericChunkCache(int max_size, boolean softref) {
         refqueue = new ReferenceQueue<ChunkCacheRec>();
         this.softref = softref;
     }
-    private String getKey(String w, int cx, int cz) {
-        return w + ":" + cx + ":" + cz;
+    /**
+     * Encode world name + chunk coords as a single long key.
+     * Worlds are assigned small integer IDs (10 bits) on first use.
+     * cx and cz are each encoded in 27 bits (signed, supports ±8M chunks / ±128M blocks).
+     * Must be called while holding snapcachelock.
+     */
+    private long getKey(String w, int cx, int cz) {
+        Integer wid = worldIds.get(w);
+        if (wid == null) {
+            wid = nextWorldId++;
+            worldIds.put(w, wid);
+        }
+        return ((long)(wid & 0x3FF) << 54) | ((long)(cx & 0x7FFFFFF) << 27) | (long)(cz & 0x7FFFFFF);
     }
     /**
      * Invalidate cached snapshot, if in cache
      */
     public void invalidateSnapshot(String w, int x, int y, int z) {
-        String key = getKey(w, x>>4, z>>4);
         synchronized(snapcachelock) {
+            long key = getKey(w, x>>4, z>>4);
             CacheRec rec = (snapcache != null) ? snapcache.remove(key) : null;
             if(rec != null) {
                 snapcache.reverselookup.remove(rec.ref);
@@ -77,10 +93,10 @@ public void invalidateSnapshot(String w, int x, int y, int z) {
      * Invalidate cached snapshot, if in cache
      */
     public void invalidateSnapshot(String w, int x0, int y0, int z0, int x1, int y1, int z1) {
-        for(int xx = (x0>>4); xx <= (x1>>4); xx++) {
-            for(int zz = (z0>>4); zz <= (z1>>4); zz++) {
-                String key = getKey(w, xx, zz);
-                synchronized(snapcachelock) {
+        synchronized(snapcachelock) {
+            for(int xx = (x0>>4); xx <= (x1>>4); xx++) {
+                for(int zz = (z0>>4); zz <= (z1>>4); zz++) {
+                    long key = getKey(w, xx, zz);
                     CacheRec rec = (snapcache != null) ? snapcache.remove(key) : null;
                     if(rec != null) {
                         snapcache.reverselookup.remove(rec.ref);
@@ -95,11 +111,11 @@ public void invalidateSnapshot(String w, int x0, int y0, int z0, int x1, int y1,
      * Look for chunk snapshot in cache
      */
     public ChunkCacheRec getSnapshot(String w, int chunkx, int chunkz) {
-        String key = getKey(w, chunkx, chunkz);
         processRefQueue();
         ChunkCacheRec ss = null;
         CacheRec rec;
         synchronized(snapcachelock) {
+            long key = getKey(w, chunkx, chunkz);
             rec = (snapcache != null) ? snapcache.get(key) : null;
             if(rec != null) {
                 ss = rec.ref.get();
@@ -118,14 +134,14 @@ public ChunkCacheRec getSnapshot(String w, int chunkx, int chunkz) {
      * Add chunk snapshot to cache
      */
     public void putSnapshot(String w, int chunkx, int chunkz, ChunkCacheRec ss) {
-        String key = getKey(w, chunkx, chunkz);
         processRefQueue();
         CacheRec rec = new CacheRec();
         if (softref)
             rec.ref = new SoftReference<ChunkCacheRec>(ss, refqueue);
         else
             rec.ref = new WeakReference<ChunkCacheRec>(ss, refqueue);
         synchronized(snapcachelock) {
+            long key = getKey(w, chunkx, chunkz);
             CacheRec prevrec = (snapcache != null) ? snapcache.put(key, rec) : null;
             if(prevrec != null) {
                 snapcache.reverselookup.remove(prevrec.ref);
@@ -140,7 +156,7 @@ private void processRefQueue() {
         Reference<? extends ChunkCacheRec> ref;
         while((ref = refqueue.poll()) != null) {
             synchronized(snapcachelock) {
-                String k = (snapcache != null) ? snapcache.reverselookup.remove(ref) : null;
+                Long k = (snapcache != null) ? snapcache.reverselookup.remove(ref) : null;
                 if(k != null) {
                     snapcache.remove(k);
                 }
diff --git a/DynmapCore/src/main/java/org/dynmap/common/chunk/GenericChunkSection.java b/DynmapCore/src/main/java/org/dynmap/common/chunk/GenericChunkSection.java
@@ -25,7 +25,7 @@ private static class BlockStateAccess3D implements BlockStateAccess {
 			blocks = bs;
 		}
 		public final DynmapBlockState getBlock(int x, int y, int z) {
-			return blocks[(256 * (y & 0xF)) + (16 * (z & 0xF)) + (x & 0xF)];
+			return blocks[((y & 0xF) << 8) | ((z & 0xF) << 4) | (x & 0xF)];
 		}
 		public final DynmapBlockState getBlock(GenericChunkPos pos) {
 			return blocks[pos.soffset];
@@ -40,7 +40,7 @@ private static class BlockStateAccess3DPalette implements BlockStateAccess {
 			palette = pal;
 		}
 		public final DynmapBlockState getBlock(int x, int y, int z) {
-			return palette[blocks[(256 * (y & 0xF)) + (16 * (z & 0xF)) + (x & 0xF)]];
+			return palette[blocks[((y & 0xF) << 8) | ((z & 0xF) << 4) | (x & 0xF)]];
 		}
 		public final DynmapBlockState getBlock(GenericChunkPos pos) {
 			return palette[blocks[pos.soffset]];
@@ -126,12 +126,12 @@ private static class LightingAccess3D implements LightingAccess {
 			light = new long[256];
 			if (lig != null) {
 				for (int off = 0; (off < lig.length) && (off < 2048); off++) {
-					light[off >> 3] |= (0xFFL & (long)lig[off]) << (8 * (off & 0x7));
+					light[off >> 3] |= (0xFFL & (long)lig[off]) << ((off & 0x7) << 3);
 				}
 			}
 		}
 		public final int getLight(int x, int y, int z) {
-			return 0xF & (int)(light[(16 * (y & 0xF)) + (z & 0xF)] >> (4 * (x & 0xF)));
+			return 0xF & (int)(light[((y & 0xF) << 4) | (z & 0xF)] >> ((x & 0xF) << 2));
 		}
 		public final int getLight(GenericChunkPos pos) {
 			return 0xF & (int)(light[pos.soffset >> 4] >> (4 * pos.sx));			
diff --git a/DynmapCore/src/main/java/org/dynmap/hdmap/ShadowHDLighting.java b/DynmapCore/src/main/java/org/dynmap/hdmap/ShadowHDLighting.java
@@ -154,9 +154,7 @@ else if(weight < 0) {   /* If negative, interpolate down */
             }
         }
         if(cscale < 256) {
-            Color c = outcolor[0];
-            c.setRGBA((c.getRed() * cscale) >> 8, (c.getGreen() * cscale) >> 8, 
-                (c.getBlue() * cscale) >> 8, c.getAlpha());
+            outcolor[0].scaleRGB(cscale);
         }
         if(outcolor.length > 1) {
             ll0 = getLightLevel(skyemit0, false);
@@ -194,9 +192,7 @@ else if(weight < 0) {   /* If negative, interpolate down */
                 }
             }
             if(cscale < 256) {
-                Color c = outcolor[1];
-                c.setRGBA((c.getRed() * cscale) >> 8, (c.getGreen() * cscale) >> 8, 
-                    (c.getBlue() * cscale) >> 8, c.getAlpha());
+                outcolor[1].scaleRGB(cscale);
             }
         }
     }
@@ -269,8 +265,7 @@ public void    applyLighting(HDPerspectiveState ps, HDShaderState ss, Color inco
     private final void shadowColor(Color c, int lightlevel, int[] shadowscale) {
         int scale = shadowscale[lightlevel];
         if(scale < 256)
-            c.setRGBA((c.getRed() * scale) >> 8, (c.getGreen() * scale) >> 8, 
-                (c.getBlue() * scale) >> 8, c.getAlpha());
+            c.scaleRGB(scale);
     }
 
 
diff --git a/DynmapCore/src/main/java/org/dynmap/utils/PatchDefinition.java b/DynmapCore/src/main/java/org/dynmap/utils/PatchDefinition.java
diff --git a/DynmapCoreAPI/src/main/java/org/dynmap/renderer/DynmapBlockState.java b/DynmapCoreAPI/src/main/java/org/dynmap/renderer/DynmapBlockState.java

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ private GenericChunk(int cx, int cz, int cy_min, GenericChunkSection[] sections,`
`38`	`38`	`// Get section for given block Y coord`
`39`	`39`	`public final GenericChunkSection getSection(int y) {`
`40`	`40`	`int idx = (y >> 4) - this.cy_min;`
`41`		`- if ((idx < 0) \|\| (idx >= sectionCnt)) {`
	`41`	`+ if ((idx < 0) \|\| (idx >= sections.length)) {`
`42`	`42`	`return GenericChunkSection.EMPTY;`
`43`	`43`	`}`
`44`	`44`	`return this.sections[idx];`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ private static class BlockStateAccess3D implements BlockStateAccess {`
`25`	`25`	`blocks = bs;`
`26`	`26`	`}`
`27`	`27`	`public final DynmapBlockState getBlock(int x, int y, int z) {`
`28`		`- return blocks[(256 * (y & 0xF)) + (16 * (z & 0xF)) + (x & 0xF)];`
	`28`	`+ return blocks[((y & 0xF) << 8) \| ((z & 0xF) << 4) \| (x & 0xF)];`
`29`	`29`	`}`
`30`	`30`	`public final DynmapBlockState getBlock(GenericChunkPos pos) {`
`31`	`31`	`return blocks[pos.soffset];`
`@@ -40,7 +40,7 @@ private static class BlockStateAccess3DPalette implements BlockStateAccess {`
`40`	`40`	`palette = pal;`
`41`	`41`	`}`
`42`	`42`	`public final DynmapBlockState getBlock(int x, int y, int z) {`
`43`		`- return palette[blocks[(256 * (y & 0xF)) + (16 * (z & 0xF)) + (x & 0xF)]];`
	`43`	`+ return palette[blocks[((y & 0xF) << 8) \| ((z & 0xF) << 4) \| (x & 0xF)]];`
`44`	`44`	`}`
`45`	`45`	`public final DynmapBlockState getBlock(GenericChunkPos pos) {`
`46`	`46`	`return palette[blocks[pos.soffset]];`
`@@ -126,12 +126,12 @@ private static class LightingAccess3D implements LightingAccess {`
`126`	`126`	`light = new long[256];`
`127`	`127`	`if (lig != null) {`
`128`	`128`	`for (int off = 0; (off < lig.length) && (off < 2048); off++) {`
`129`		`- light[off >> 3] \|= (0xFFL & (long)lig[off]) << (8 * (off & 0x7));`
	`129`	`+ light[off >> 3] \|= (0xFFL & (long)lig[off]) << ((off & 0x7) << 3);`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`	`}`
`133`	`133`	`public final int getLight(int x, int y, int z) {`
`134`		`- return 0xF & (int)(light[(16 * (y & 0xF)) + (z & 0xF)] >> (4 * (x & 0xF)));`
	`134`	`+ return 0xF & (int)(light[((y & 0xF) << 4) \| (z & 0xF)] >> ((x & 0xF) << 2));`
`135`	`135`	`}`
`136`	`136`	`public final int getLight(GenericChunkPos pos) {`
`137`	`137`	`return 0xF & (int)(light[pos.soffset >> 4] >> (4 * pos.sx));`
Original file line number	Diff line number	Diff line change
`@@ -154,9 +154,7 @@ else if(weight < 0) { /* If negative, interpolate down */`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`	`if(cscale < 256) {`
`157`		`- Color c = outcolor[0];`
`158`		`- c.setRGBA((c.getRed() * cscale) >> 8, (c.getGreen() * cscale) >> 8,`
`159`		`- (c.getBlue() * cscale) >> 8, c.getAlpha());`
	`157`	`+ outcolor[0].scaleRGB(cscale);`
`160`	`158`	`}`
`161`	`159`	`if(outcolor.length > 1) {`
`162`	`160`	`ll0 = getLightLevel(skyemit0, false);`
`@@ -194,9 +192,7 @@ else if(weight < 0) { /* If negative, interpolate down */`
`194`	`192`	`}`
`195`	`193`	`}`
`196`	`194`	`if(cscale < 256) {`
`197`		`- Color c = outcolor[1];`
`198`		`- c.setRGBA((c.getRed() * cscale) >> 8, (c.getGreen() * cscale) >> 8,`
`199`		`- (c.getBlue() * cscale) >> 8, c.getAlpha());`
	`195`	`+ outcolor[1].scaleRGB(cscale);`
`200`	`196`	`}`
`201`	`197`	`}`
`202`	`198`	`}`
`@@ -269,8 +265,7 @@ public void applyLighting(HDPerspectiveState ps, HDShaderState ss, Color inco`
`269`	`265`	`private final void shadowColor(Color c, int lightlevel, int[] shadowscale) {`
`270`	`266`	`int scale = shadowscale[lightlevel];`
`271`	`267`	`if(scale < 256)`
`272`		`- c.setRGBA((c.getRed() * scale) >> 8, (c.getGreen() * scale) >> 8,`
`273`		`- (c.getBlue() * scale) >> 8, c.getAlpha());`
	`268`	`+ c.scaleRGB(scale);`
`274`	`269`	`}`
`275`	`270`
`276`	`271`