Extend and refactor sampler management

xCollateral · xCollateral · commit b044f06db6ff · 2026-01-04T16:27:42.000+01:00
diff --git a/src/main/java/net/vulkanmod/gl/VkGlRenderbuffer.java b/src/main/java/net/vulkanmod/gl/VkGlRenderbuffer.java
@@ -159,16 +159,34 @@ void updateSampler() {
         if (vulkanImage == null)
             return;
 
-        byte samplerFlags = magFilter == GL11.GL_LINEAR ? SamplerManager.LINEAR_FILTERING_BIT : 0;
+        int addressMode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+        int vkMagFilter, vkMinFilter, mipmapMode;
 
-        samplerFlags |= switch (minFilter) {
-            case GL11.GL_LINEAR_MIPMAP_LINEAR ->
-                    SamplerManager.USE_MIPMAPS_BIT | SamplerManager.MIPMAP_LINEAR_FILTERING_BIT;
-            case GL11.GL_NEAREST_MIPMAP_NEAREST -> SamplerManager.USE_MIPMAPS_BIT;
-            default -> 0;
+        switch (minFilter) {
+            case GL11.GL_LINEAR_MIPMAP_LINEAR, GL11.GL_LINEAR -> {
+                vkMinFilter = VK_FILTER_LINEAR; mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
+            }
+            case GL11.GL_LINEAR_MIPMAP_NEAREST -> {
+                vkMinFilter = VK_FILTER_LINEAR; mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
+            }
+            case GL11.GL_NEAREST_MIPMAP_NEAREST, GL11.GL_NEAREST -> {
+                vkMinFilter = VK_FILTER_NEAREST; mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
+            }
+            case GL11.GL_NEAREST_MIPMAP_LINEAR -> {
+                vkMinFilter = VK_FILTER_NEAREST; mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
+            }
+            default -> throw new IllegalStateException("Unexpected min filter value: %d".formatted(minFilter));
+        }
+
+        vkMagFilter = switch (magFilter) {
+            case GL11.GL_LINEAR -> VK_FILTER_LINEAR;
+            case GL11.GL_NEAREST -> VK_FILTER_NEAREST;
+            default -> throw new IllegalStateException("Unexpected mag filter value: %d".formatted(magFilter));
         };
 
-        vulkanImage.updateTextureSampler(maxLod, samplerFlags);
+        long sampler = SamplerManager.getSampler(addressMode, addressMode, vkMinFilter, vkMagFilter, mipmapMode, maxLod, false, 0, -1);
+
+        vulkanImage.setSampler(sampler);
     }
 
     private void uploadImage(ByteBuffer pixels) {
diff --git a/src/main/java/net/vulkanmod/gl/VkGlTexture.java b/src/main/java/net/vulkanmod/gl/VkGlTexture.java
@@ -279,7 +279,7 @@ public static VkGlTexture getBoundTexture() {
     boolean needsUpdate = false;
     int maxLevel = 0;
     int maxLod = 0;
-    int minFilter, magFilter = GL11.GL_LINEAR;
+    int minFilter = GL11.GL_NEAREST, magFilter = GL11.GL_NEAREST;
 
     boolean clamp = true;
 
@@ -340,17 +340,34 @@ void updateSampler() {
         if (vulkanImage == null)
             return;
 
-        byte samplerFlags;
-        samplerFlags = clamp ? SamplerManager.CLAMP_BIT : 0;
-        samplerFlags |= magFilter == GL11.GL_LINEAR ? SamplerManager.LINEAR_FILTERING_BIT : 0;
+        int addressMode = clamp ? VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE : VK_SAMPLER_ADDRESS_MODE_REPEAT;
+        int vkMagFilter, vkMinFilter, mipmapMode;
 
-        samplerFlags |= switch (minFilter) {
-            case GL11.GL_LINEAR_MIPMAP_LINEAR -> SamplerManager.USE_MIPMAPS_BIT | SamplerManager.MIPMAP_LINEAR_FILTERING_BIT;
-            case GL11.GL_NEAREST_MIPMAP_NEAREST -> SamplerManager.USE_MIPMAPS_BIT;
-            default -> 0;
+        switch (minFilter) {
+            case GL11.GL_LINEAR_MIPMAP_LINEAR, GL11.GL_LINEAR -> {
+                vkMinFilter = VK_FILTER_LINEAR; mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
+            }
+            case GL11.GL_LINEAR_MIPMAP_NEAREST -> {
+                vkMinFilter = VK_FILTER_LINEAR; mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
+            }
+            case GL11.GL_NEAREST_MIPMAP_NEAREST, GL11.GL_NEAREST -> {
+                vkMinFilter = VK_FILTER_NEAREST; mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
+            }
+            case GL11.GL_NEAREST_MIPMAP_LINEAR -> {
+                vkMinFilter = VK_FILTER_NEAREST; mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
+            }
+            default -> throw new IllegalStateException("Unexpected min filter value: %d".formatted(minFilter));
+        }
+
+        vkMagFilter = switch (magFilter) {
+            case GL11.GL_LINEAR -> VK_FILTER_LINEAR;
+            case GL11.GL_NEAREST -> VK_FILTER_NEAREST;
+            default -> throw new IllegalStateException("Unexpected mag filter value: %d".formatted(magFilter));
         };
 
-        vulkanImage.updateTextureSampler(maxLod, samplerFlags);
+        long sampler = SamplerManager.getSampler(addressMode, addressMode, vkMinFilter, vkMagFilter, mipmapMode, maxLod, false, 0, -1);
+
+        vulkanImage.setSampler(sampler);
     }
 
     private void uploadSubImage(int level, int xOffset, int yOffset, int width, int height, int format, ByteBuffer pixels) {
diff --git a/src/main/java/net/vulkanmod/render/engine/VkGpuTexture.java b/src/main/java/net/vulkanmod/render/engine/VkGpuTexture.java
@@ -55,16 +55,16 @@ public boolean isClosed() {
 
     public void flushModeChanges() {
         if (this.modesDirty) {
-            byte samplerFlags;
-            samplerFlags = magFilter == FilterMode.LINEAR ? SamplerManager.LINEAR_FILTERING_BIT : 0;
+            int maxLod = this.useMipmaps ? this.getMipLevels() - 1 : 0;
 
-            // TODO: split min filtering
+            int magFilterVk = magFilter == FilterMode.LINEAR ? VK10.VK_FILTER_LINEAR : VK10.VK_FILTER_NEAREST;
+            int minFilterVk = minFilter == FilterMode.LINEAR ? VK10.VK_FILTER_LINEAR : VK10.VK_FILTER_NEAREST;
 
-            if (this.useMipmaps) {
-                samplerFlags |= SamplerManager.USE_MIPMAPS_BIT | SamplerManager.MIPMAP_LINEAR_FILTERING_BIT;
-            }
+            long sampler = SamplerManager.getSampler(VK10.VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, VK10.VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+                                                     minFilterVk, magFilterVk, VK10.VK_SAMPLER_MIPMAP_MODE_LINEAR,
+                                                     maxLod, false, 0, -1);
 
-            glTexture.getVulkanImage().updateTextureSampler(this.getMipLevels(), samplerFlags);
+            glTexture.getVulkanImage().setSampler(sampler);
 
             this.modesDirty = false;
         }
diff --git a/src/main/java/net/vulkanmod/vulkan/framebuffer/SwapChain.java b/src/main/java/net/vulkanmod/vulkan/framebuffer/SwapChain.java
@@ -7,6 +7,7 @@
 import net.vulkanmod.vulkan.Vulkan;
 import net.vulkanmod.vulkan.device.DeviceManager;
 import net.vulkanmod.vulkan.queue.Queue;
+import net.vulkanmod.vulkan.texture.SamplerManager;
 import net.vulkanmod.vulkan.texture.VulkanImage;
 import org.lwjgl.system.MemoryStack;
 import org.lwjgl.vulkan.*;
@@ -152,7 +153,8 @@ private void createSwapChain() {
                 long imageView = VulkanImage.createImageView(imageId, this.format, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1);
 
                 VulkanImage image = new VulkanImage("Swapchain", imageId, this.format, 1, this.width, this.height, 4, 0, imageView);
-                image.updateTextureSampler(true, true, false);
+                long samplerId = SamplerManager.getSampler(true, true, 0);
+                image.setSampler(samplerId);
                 this.swapChainImages.add(image);
             }
         }
diff --git a/src/main/java/net/vulkanmod/vulkan/texture/SamplerManager.java b/src/main/java/net/vulkanmod/vulkan/texture/SamplerManager.java
@@ -1,9 +1,8 @@
 package net.vulkanmod.vulkan.texture;
 
-import it.unimi.dsi.fastutil.shorts.Short2LongMap;
-import it.unimi.dsi.fastutil.shorts.Short2LongOpenHashMap;
+import it.unimi.dsi.fastutil.objects.Object2LongMap;
+import it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap;
 import net.vulkanmod.vulkan.device.DeviceManager;
-import org.apache.commons.lang3.Validate;
 import org.lwjgl.system.MemoryStack;
 import org.lwjgl.vulkan.VkSamplerCreateInfo;
 import org.lwjgl.vulkan.VkSamplerReductionModeCreateInfo;
@@ -13,81 +12,86 @@
 import static net.vulkanmod.vulkan.Vulkan.getVkDevice;
 import static org.lwjgl.system.MemoryStack.stackPush;
 import static org.lwjgl.vulkan.VK10.*;
-import static org.lwjgl.vulkan.VK12.VK_SAMPLER_REDUCTION_MODE_MAX;
-import static org.lwjgl.vulkan.VK12.VK_SAMPLER_REDUCTION_MODE_MIN;
 
 public abstract class SamplerManager {
+    public static final int ADDRESS_MODE_BITS = 2;
+    public static final int REDUCTION_MODE_BITS = 2;
+
+    public static final int ADDRESS_MODE_U_OFFSET = 0;
+    public static final int ADDRESS_MODE_V_OFFSET = 2;
+    public static final int MIN_FILTER_OFFSET = 4;
+    public static final int MAG_FILTER_OFFSET = 5;
+    public static final int MIPMAP_MODE_OFFSET = 6;
+    public static final int ANISOTROPY_OFFSET = 7;
+    public static final int REDUCTION_MODE_ENABLE_OFFSET = 8;
+    public static final int REDUCTION_MODE_OFFSET = 9;
+
     static final float MIP_BIAS = -0.5f;
 
-    static final Short2LongMap SAMPLERS = new Short2LongOpenHashMap();
+    static final Object2LongMap<SamplerInfo> SAMPLERS = new Object2LongOpenHashMap<>();
+
+    public static long getSampler(boolean clamp, boolean linearFiltering, int maxLod) {
+        return getSampler(clamp, linearFiltering, maxLod, false, 0);
+    }
+
+    public static long getSampler(boolean clamp, boolean linearFiltering, int maxLod, boolean anisotropy, int maxAnisotropy) {
+        int addressMode = clamp ? VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE : VK_SAMPLER_ADDRESS_MODE_REPEAT;
+        int filter = linearFiltering ? VK_FILTER_LINEAR : VK_FILTER_NEAREST;
+        int mipmapMode = linearFiltering ? VK_SAMPLER_MIPMAP_MODE_LINEAR : VK_SAMPLER_MIPMAP_MODE_NEAREST;
+
+        return getSampler(addressMode, addressMode, filter, filter, mipmapMode, maxLod, anisotropy, maxAnisotropy, -1);
+    }
+
+    public static long getSampler(int addressModeU, int addressModeV,
+                                  int minFilter, int magFilter, int mipmapMode, float maxLod,
+                                  boolean anisotropy, float maxAnisotropy, int reductionMode) {
+        SamplerInfo samplerInfo = new SamplerInfo(addressModeU, addressModeV, minFilter, magFilter, mipmapMode, maxLod, anisotropy, maxAnisotropy, reductionMode);
 
-    public static long getTextureSampler(byte maxLod, byte flags) {
-        short key = (short) (flags | (maxLod << 8));
-        long sampler = SAMPLERS.getOrDefault(key, 0L);
+        long sampler = SAMPLERS.getOrDefault(samplerInfo, 0L);
 
         if (sampler == 0L) {
-            sampler = createTextureSampler(maxLod, flags);
-            SAMPLERS.put(key, sampler);
+            sampler = createTextureSampler(samplerInfo);
+            SAMPLERS.put(samplerInfo, sampler);
         }
 
         return sampler;
     }
 
-    private static long createTextureSampler(byte maxLod, byte flags) {
-        Validate.isTrue(
-                (flags & (REDUCTION_MIN_BIT | REDUCTION_MAX_BIT)) != (REDUCTION_MIN_BIT | REDUCTION_MAX_BIT)
-        );
+    public static long getDefaultSampler() {
+        return getSampler(false, false, 0);
+    }
 
-        try (MemoryStack stack = stackPush()) {
+    private static long createTextureSampler(SamplerInfo sampler) {
+        int state = sampler.encodedState;
 
+        try (MemoryStack stack = stackPush()) {
             VkSamplerCreateInfo samplerInfo = VkSamplerCreateInfo.calloc(stack);
             samplerInfo.sType(VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
 
-            if ((flags & LINEAR_FILTERING_BIT) != 0) {
-                samplerInfo.magFilter(VK_FILTER_LINEAR);
-                samplerInfo.minFilter(VK_FILTER_LINEAR);
-            } else {
-                samplerInfo.magFilter(VK_FILTER_NEAREST);
-                samplerInfo.minFilter(VK_FILTER_NEAREST);
-            }
+            samplerInfo.magFilter(sampler.getMagFilter());
+            samplerInfo.minFilter(sampler.getMinFilter());
 
-            if ((flags & CLAMP_BIT) != 0) {
-                samplerInfo.addressModeU(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
-                samplerInfo.addressModeV(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
-                samplerInfo.addressModeW(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
-            } else {
-                samplerInfo.addressModeU(VK_SAMPLER_ADDRESS_MODE_REPEAT);
-                samplerInfo.addressModeV(VK_SAMPLER_ADDRESS_MODE_REPEAT);
-                samplerInfo.addressModeW(VK_SAMPLER_ADDRESS_MODE_REPEAT);
-            }
+            samplerInfo.addressModeU(sampler.getAddressModeU());
+            samplerInfo.addressModeV(sampler.getAddressModeV());
+            samplerInfo.addressModeW(VK_SAMPLER_ADDRESS_MODE_REPEAT);
 
-            samplerInfo.anisotropyEnable(false);
-            //samplerInfo.maxAnisotropy(16.0f);
+            samplerInfo.anisotropyEnable(sampler.getAnisotropy());
+            samplerInfo.maxAnisotropy(sampler.getMaxAnisotropy());
             samplerInfo.borderColor(VK_BORDER_COLOR_INT_OPAQUE_WHITE);
             samplerInfo.unnormalizedCoordinates(false);
             samplerInfo.compareEnable(false);
             samplerInfo.compareOp(VK_COMPARE_OP_ALWAYS);
 
-            if ((flags & USE_MIPMAPS_BIT) == 0) {
-                samplerInfo.mipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST);
-                samplerInfo.maxLod(0.0F);
-                samplerInfo.minLod(0.0F);
-            } else {
-                if ((flags & MIPMAP_LINEAR_FILTERING_BIT) != 0) {
-                    samplerInfo.mipmapMode(VK_SAMPLER_MIPMAP_MODE_LINEAR);
-                } else {
-                    samplerInfo.mipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST);
-                }
-                samplerInfo.maxLod(maxLod);
-                samplerInfo.minLod(0.0F);
-                samplerInfo.mipLodBias(MIP_BIAS);
-            }
+            samplerInfo.mipmapMode(sampler.getMipmapMode());
+            samplerInfo.maxLod(sampler.getMaxLod());
+            samplerInfo.minLod(0.0F);
+            samplerInfo.mipLodBias(MIP_BIAS);
 
-            //Reduction Mode
-            if ((flags & (REDUCTION_MAX_BIT | REDUCTION_MIN_BIT)) != 0) {
+            // Reduction Mode
+            if (sampler.hasReductionMode()) {
                 VkSamplerReductionModeCreateInfo reductionModeInfo = VkSamplerReductionModeCreateInfo.calloc(stack);
                 reductionModeInfo.sType$Default();
-                reductionModeInfo.reductionMode((flags & REDUCTION_MAX_BIT) != 0 ? VK_SAMPLER_REDUCTION_MODE_MAX : VK_SAMPLER_REDUCTION_MODE_MIN);
+                reductionModeInfo.reductionMode(sampler.getReductionMode());
                 samplerInfo.pNext(reductionModeInfo.address());
             }
 
@@ -107,10 +111,91 @@ public static void cleanUp() {
         }
     }
 
-    public static final byte LINEAR_FILTERING_BIT = 0b1;
-    public static final byte CLAMP_BIT = 0b10;
-    public static final byte USE_MIPMAPS_BIT = 0b100;
-    public static final byte MIPMAP_LINEAR_FILTERING_BIT = 0b1000;
-    public static final byte REDUCTION_MIN_BIT = 0b10000;
-    public static final byte REDUCTION_MAX_BIT = 0b100000;
+    public static class SamplerInfo {
+        final int encodedState;
+        final int maxLod;
+        final int maxAnisotropy;
+
+        public SamplerInfo() {
+            this(VK_SAMPLER_ADDRESS_MODE_REPEAT, VK_SAMPLER_ADDRESS_MODE_REPEAT,
+                 VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST,
+                 0, false, 0, -1);
+        }
+
+
+
+        public SamplerInfo(int addressModeU, int addressModeV, int minFilter, int magFilter, int mipmapMode,
+                           float maxLod, boolean anisotropy, float maxAnisotropy, int reductionMode) {
+            this.maxLod = (int) maxLod;
+            this.maxAnisotropy = (int) maxAnisotropy;
+
+            int encodedState = (addressModeU & ADDRESS_MODE_BITS) << ADDRESS_MODE_U_OFFSET;
+            encodedState |= (addressModeV & ADDRESS_MODE_BITS) << ADDRESS_MODE_V_OFFSET;
+            encodedState |= (minFilter & 1) << MIN_FILTER_OFFSET;
+            encodedState |= (magFilter & 1) << MAG_FILTER_OFFSET;
+            encodedState |= (mipmapMode & 1) << MIPMAP_MODE_OFFSET;
+            encodedState |= ((anisotropy ? 1 : 0) & 1) << ANISOTROPY_OFFSET;
+            encodedState |= (reductionMode != -1 ? 1 : 0) << REDUCTION_MODE_ENABLE_OFFSET;
+            encodedState |= (reductionMode & REDUCTION_MODE_BITS) << REDUCTION_MODE_OFFSET;
+
+            this.encodedState = encodedState;
+        }
+
+        public int getAddressModeU() {
+            return (this.encodedState >> ADDRESS_MODE_U_OFFSET) & ADDRESS_MODE_BITS;
+        }
+
+        public int getAddressModeV() {
+            return (this.encodedState >> ADDRESS_MODE_V_OFFSET) & ADDRESS_MODE_BITS;
+        }
+
+        public int getMinFilter() {
+            return (this.encodedState >> MIN_FILTER_OFFSET) & 1;
+        }
+
+        public int getMagFilter() {
+            return (this.encodedState >> MAG_FILTER_OFFSET) & 1;
+        }
+
+        public int getMipmapMode() {
+            return (this.encodedState >> MIPMAP_MODE_OFFSET) & 1;
+        }
+
+        public boolean getAnisotropy() {
+            return ((this.encodedState >> ANISOTROPY_OFFSET) & 1) != 0;
+        }
+
+        public boolean hasReductionMode() {
+            return ((this.encodedState >> REDUCTION_MODE_ENABLE_OFFSET) & 1) != 0;
+        }
+
+        public int getReductionMode() {
+            return (this.encodedState >> REDUCTION_MODE_OFFSET) & REDUCTION_MODE_BITS;
+        }
+
+        public int getMaxAnisotropy() {
+            return maxAnisotropy;
+        }
+
+        public int getMaxLod() {
+            return maxLod;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o == null || getClass() != o.getClass()) return false;
+
+            SamplerInfo samplerInfo = (SamplerInfo) o;
+            return maxLod == samplerInfo.maxLod && maxAnisotropy == samplerInfo.maxAnisotropy && encodedState == samplerInfo.encodedState;
+        }
+
+        @Override
+        public int hashCode() {
+            int result = encodedState;
+            result = 31 * result + maxLod;
+            result = 31 * result + maxAnisotropy;
+            return result;
+        }
+    }
+
 }
diff --git a/src/main/java/net/vulkanmod/vulkan/texture/VulkanImage.java b/src/main/java/net/vulkanmod/vulkan/texture/VulkanImage.java
