Refactor: extract selectFormat() helper, remove code duplication in StbImageLoader

Agent-Logs-Url: https://github.com/jMonkeyEngine/jmonkeyengine/sessions/06d3e2b9-a0ea-4a94-b058-73910f64df28

Co-authored-by: riccardobl <4943530+riccardobl@users.noreply.github.com>

Author: Copilot

jme3-plugins/src/main/java/com/jme3/texture/plugins/StbImageLoader.java

@@ -54,62 +54,17 @@ public Image load(byte[] data, boolean flipY) throws IOException {
 
         int width = info.getWidth();
         int height = info.getHeight();
+        // When channels == 0 the decoder will choose its natural output count.
         int desiredChannels = channels;
 
         boolean is16bit = info.is16Bit();
         boolean isFloat = info.isFloat();
-        boolean sRGB = false;
-
 
         // Some formats (e.g., TGA) don't report channel count via info().
         // When channels == 0, load first and determine the format afterwards.
         Image.Format jmeFormat = null;
         if (channels != 0) {
-            if (is16bit || isFloat) {
-                switch (channels) {
-                    case 1:
-                        jmeFormat = Image.Format.Luminance16F;
-                        desiredChannels = 1;
-                        break;
-                    case 2:
-                        jmeFormat = Image.Format.Luminance16FAlpha16F;
-                        desiredChannels = 2;
-                        break;
-                    case 3:
-                        jmeFormat = Image.Format.RGB16F;
-                        desiredChannels = 3;
-                        break;
-                    case 4:
-                        jmeFormat = Image.Format.RGBA16F;
-                        desiredChannels = 4;
-                        break;
-                    default:
-                        throw new IOException("Unsupported number of channels: " + channels);
-                }
-            } else {
-                switch (channels) {
-                    case 1:
-                        jmeFormat = Image.Format.Luminance8;
-                        desiredChannels = 1;
-                        break;
-                    case 2:
-                        jmeFormat = Image.Format.Luminance8Alpha8;
-                        desiredChannels = 2;
-                        break;
-                    case 3:
-                        jmeFormat = Image.Format.RGB8;
-                        desiredChannels = 3;
-                        sRGB = true;
-                        break;
-                    case 4:
-                        jmeFormat = Image.Format.RGBA8;
-                        desiredChannels = 4;
-                        sRGB = true;
-                        break;
-                    default:
-                        throw new IOException("Unsupported number of channels: " + channels);
-                }
-            }
+            jmeFormat = selectFormat(channels, is16bit, isFloat);
         }
 
         StbImageResult imgData;
@@ -124,46 +79,10 @@ public Image load(byte[] data, boolean flipY) throws IOException {
         if (channels == 0) {
             // Channel count was not available from info(); derive the format from
             // the number of channels actually produced by the decoder.
-            int actualChannels = imgData.getChannels();
-            if (is16bit || isFloat) {
-                switch (actualChannels) {
-                    case 1:
-                        jmeFormat = Image.Format.Luminance16F;
-                        break;
-                    case 2:
-                        jmeFormat = Image.Format.Luminance16FAlpha16F;
-                        break;
-                    case 3:
-                        jmeFormat = Image.Format.RGB16F;
-                        break;
-                    case 4:
-                        jmeFormat = Image.Format.RGBA16F;
-                        break;
-                    default:
-                        throw new IOException("Unsupported number of channels: " + actualChannels);
-                }
-            } else {
-                switch (actualChannels) {
-                    case 1:
-                        jmeFormat = Image.Format.Luminance8;
-                        break;
-                    case 2:
-                        jmeFormat = Image.Format.Luminance8Alpha8;
-                        break;
-                    case 3:
-                        jmeFormat = Image.Format.RGB8;
-                        sRGB = true;
-                        break;
-                    case 4:
-                        jmeFormat = Image.Format.RGBA8;
-                        sRGB = true;
-                        break;
-                    default:
-                        throw new IOException("Unsupported number of channels: " + actualChannels);
-                }
-            }
+            jmeFormat = selectFormat(imgData.getChannels(), is16bit, isFloat);
         }
 
+        boolean sRGB = (jmeFormat == Image.Format.RGB8 || jmeFormat == Image.Format.RGBA8);
         ByteBuffer jmeImageBuffer = convertImageData(imgData, jmeFormat);
 
         return new Image(jmeFormat, width, height, jmeImageBuffer, sRGB ? ColorSpace.sRGB : ColorSpace.Linear);
@@ -184,6 +103,36 @@ public Object load(AssetInfo assetInfo) throws IOException {
         }
     }
 
+    /**
+     * Maps a channel count and bit-depth to the corresponding {@link Image.Format}.
+     *
+     * @param channels  number of channels (1–4)
+     * @param is16bit   {@code true} for 16-bit-per-channel source data
+     * @param isFloat   {@code true} for floating-point source data
+     * @return the matching {@link Image.Format}
+     * @throws IOException if {@code channels} is outside the supported range
+     */
+    private static Image.Format selectFormat(int channels, boolean is16bit, boolean isFloat)
+            throws IOException {
+        if (is16bit || isFloat) {
+            switch (channels) {
+                case 1: return Image.Format.Luminance16F;
+                case 2: return Image.Format.Luminance16FAlpha16F;
+                case 3: return Image.Format.RGB16F;
+                case 4: return Image.Format.RGBA16F;
+                default: throw new IOException("Unsupported number of channels: " + channels);
+            }
+        } else {
+            switch (channels) {
+                case 1: return Image.Format.Luminance8;
+                case 2: return Image.Format.Luminance8Alpha8;
+                case 3: return Image.Format.RGB8;
+                case 4: return Image.Format.RGBA8;
+                default: throw new IOException("Unsupported number of channels: " + channels);
+            }
+        }
+    }
+
     private ByteBuffer convertImageData(StbImageResult imgData, Image.Format jmeFormat) {
         int outputSize = jmeFormat.getBitsPerPixel() / 8 * imgData.getWidth() * imgData.getHeight();
         ByteBuffer jmeImageBuffer = BufferUtils.createByteBuffer(outputSize);