added depth testing; added enums for image properties

codex128 · codex128 · commit 8e7ff36d42e4 · 2025-08-01T11:10:32.000-04:00
diff --git a/jme3-core/src/main/java/com/jme3/renderer/vulkan/VulkanUtils.java b/jme3-core/src/main/java/com/jme3/renderer/vulkan/VulkanUtils.java
@@ -148,18 +148,6 @@ public static LongBuffer accumulate(MemoryStack stack, Native<Long>... natives)
         return buf;
     }
 
-    public static int[] getTransferArguments(int srcLayout, int dstLayout) {
-        // output array format: {srcAccessMask, dstAccessMask, srcStage, dstStage}
-        if (srcLayout == VK_IMAGE_LAYOUT_UNDEFINED && dstLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
-            return new int[] {0, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT};
-        } else if (srcLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && dstLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
-            return new int[] {VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
-                    VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT};
-        } else {
-            throw new UnsupportedOperationException("Unsupported layer transitions.");
-        }
-    }
-
     public static class NativeIterator <T> implements Iterable<T>, Iterator<T> {
 
         private final PointerBuffer pointers;
diff --git a/jme3-examples/src/main/java/jme3test/vulkan/VulkanHelperTest.java b/jme3-examples/src/main/java/jme3test/vulkan/VulkanHelperTest.java
@@ -6,6 +6,7 @@
 import com.jme3.math.Quaternion;
 import com.jme3.math.Transform;
 import com.jme3.math.Vector3f;
+import com.jme3.opencl.CommandQueue;
 import com.jme3.renderer.vulkan.VulkanUtils;
 import com.jme3.shaderc.ShaderType;
 import com.jme3.shaderc.ShadercLoader;
@@ -62,15 +63,31 @@ public class VulkanHelperTest extends SimpleApplication implements SwapchainUpda
 
     private VulkanLogger logger;
 
+    // mesh
     private final FloatBuffer vertexData = BufferUtils.createFloatBuffer(
-            -0.5f, -0.5f,   1f, 0f, 0f,   1f, 0f,
-             0.5f, -0.5f,   0f, 1f, 0f,   0f, 0f,
-             0.5f,  0.5f,   0f, 0f, 1f,   0f, 1f,
-            -0.5f,  0.5f,   1f, 1f, 1f,   1f, 1f);
-    private final IntBuffer indexData = BufferUtils.createIntBuffer(0, 1, 2, 2, 3, 0);
+            -0.5f, -0.5f, 0f,   1f, 0f, 0f,   1f, 0f,
+             0.5f, -0.5f, 0f,   0f, 1f, 0f,   0f, 0f,
+             0.5f,  0.5f, 0f,   0f, 0f, 1f,   0f, 1f,
+            -0.5f,  0.5f, 0f,   1f, 1f, 1f,   1f, 1f,
+
+            -0.5f, -0.5f, -0.5f,   1f, 0f, 0f,   1f, 0f,
+             0.5f, -0.5f, -0.5f,   0f, 1f, 0f,   0f, 0f,
+             0.5f,  0.5f, -0.5f,   0f, 0f, 1f,   0f, 1f,
+            -0.5f,  0.5f, -0.5f,   1f, 1f, 1f,   1f, 1f
+    );
+    private final IntBuffer indexData = BufferUtils.createIntBuffer(
+            0, 1, 2, 2, 3, 0,
+            4, 5, 6, 6, 7, 4);
+
+    // geometry
     private final Transform modelTransform = new Transform();
+
+    // material
     private Texture texture;
 
+    // framebuffer
+    private ImageView depthView;
+
     public static void main(String[] args) {
         VulkanHelperTest app = new VulkanHelperTest();
         AppSettings settings = new AppSettings(true);
@@ -145,6 +162,23 @@ public void simpleInitApp() {
         descriptorPool = new DescriptorPool(device, 2,
                 PoolSize.uniformBuffers(2), PoolSize.combinedImageSamplers(2));
 
+        CommandPool transferPool = new CommandPool(device, queues.getGraphicsQueue(), true, false);
+
+        // depth texture
+        Image.Format depthFormat = device.getPhysicalDevice().findSupportedFormat(
+                VK_IMAGE_TILING_OPTIMAL,
+                VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
+                Image.Format.Depth32SFloat, Image.Format.Depth32SFloat_Stencil8UInt, Image.Format.Depth24UNorm_Stencil8UInt);
+        GpuImage depthImage = new GpuImage(device, swapchain.getExtent().x, swapchain.getExtent().y, depthFormat,
+                Image.Tiling.Optimal, new ImageUsageFlags().depthStencilAttachment(), new MemoryFlags().deviceLocal());
+        depthView = depthImage.createView(VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1);
+        CommandBuffer commands = transferPool.allocateOneTimeCommandBuffer();
+        commands.begin();
+        depthImage.transitionLayout(commands, Image.Layout.Undefined, Image.Layout.DepthStencilAttachmentOptimal);
+        commands.end();
+        commands.submit(null, null, null);
+        commands.getPool().getQueue().waitIdle();
+
         // pipeline
         pipelineLayout = new PipelineLayout(device, descriptorLayout);
         vertModule = new ShaderModule(device, assetManager.loadAsset(ShadercLoader.key(
@@ -153,37 +187,48 @@ public void simpleInitApp() {
                 "Shaders/VulkanFragTest.glsl", ShaderType.Fragment)), "main");
         try (RenderPassBuilder pass = new RenderPassBuilder()) {
             int color = pass.createAttachment(a -> a
-                    .format(swapchain.getFormat())
+                    .format(swapchain.getFormat().getVkEnum())
                     .samples(VK_SAMPLE_COUNT_1_BIT)
                     .loadOp(VK_ATTACHMENT_LOAD_OP_CLEAR)
                     .storeOp(VK_ATTACHMENT_STORE_OP_STORE)
                     .stencilLoadOp(VK_ATTACHMENT_LOAD_OP_DONT_CARE)
                     .stencilStoreOp(VK_ATTACHMENT_STORE_OP_DONT_CARE)
-                    .initialLayout(VK_IMAGE_LAYOUT_UNDEFINED)
-                    .finalLayout(KHRSwapchain.VK_IMAGE_LAYOUT_PRESENT_SRC_KHR));
+                    .initialLayout(Image.Layout.Undefined.getVkEnum())
+                    .finalLayout(Image.Layout.PresentSrc.getVkEnum()));
+            int depth = pass.createAttachment(a -> a
+                    .format(depthFormat.getVkEnum())
+                    .samples(VK_SAMPLE_COUNT_1_BIT)
+                    .loadOp(VK_ATTACHMENT_LOAD_OP_CLEAR)
+                    .storeOp(VK_ATTACHMENT_STORE_OP_DONT_CARE)
+                    .stencilLoadOp(VK_ATTACHMENT_LOAD_OP_DONT_CARE)
+                    .stencilStoreOp(VK_ATTACHMENT_STORE_OP_DONT_CARE)
+                    .initialLayout(Image.Layout.Undefined.getVkEnum())
+                    .finalLayout(Image.Layout.DepthStencilAttachmentOptimal.getVkEnum()));
             int subpass = pass.createSubpass(s -> {
-                VkAttachmentReference.Buffer ref = VkAttachmentReference.calloc(1, pass.getStack())
+                VkAttachmentReference.Buffer colorRef = VkAttachmentReference.calloc(1, pass.getStack())
                         .attachment(color)
-                        .layout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+                        .layout(Image.Layout.ColorAttachmentOptimal.getVkEnum());
+                VkAttachmentReference depthRef = VkAttachmentReference.calloc(pass.getStack())
+                        .attachment(depth)
+                        .layout(Image.Layout.DepthStencilAttachmentOptimal.getVkEnum());
                 s.pipelineBindPoint(VK_PIPELINE_BIND_POINT_GRAPHICS)
                         .colorAttachmentCount(1)
-                        .pColorAttachments(ref);
+                        .pColorAttachments(colorRef)
+                        .pDepthStencilAttachment(depthRef);
             });
             pass.createDependency()
                     .srcSubpass(VK_SUBPASS_EXTERNAL)
                     .dstSubpass(subpass)
-                    .srcStageMask(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT)
+                    .srcStageMask(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT)
                     .srcAccessMask(subpass)
-                    .dstStageMask(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT)
-                    .dstAccessMask(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
+                    .dstStageMask(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT)
+                    .dstAccessMask(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
             renderPass = pass.build(device);
         }
-        swapchain.createFrameBuffers(renderPass);
+        swapchain.createFrameBuffers(renderPass, depthView);
         pipeline = new GraphicsPipeline(device, pipelineLayout, renderPass, new RenderState(), vertModule, fragModule, new MeshDescription());
         graphicsPool = new CommandPool(device, queues.getGraphicsQueue(), false, true);
 
-        CommandPool transferPool = new CommandPool(device, queues.getGraphicsQueue(), true, false);
-
         // vertex buffers
         try (MemoryStack stack = MemoryStack.stackPush()) {
             // cpu-accessible memory is not usually fast for the gpu to access, but
@@ -203,6 +248,7 @@ public void simpleInitApp() {
             indexBuffer.freeStagingBuffer();
         }
 
+        // material color texture
         GpuImage image = loadImage("Common/Textures/MissingTexture.png", transferPool);
         texture = new Texture(device, image.createView(VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1),
                 VK_FILTER_LINEAR, VK_FILTER_LINEAR, VK_SAMPLER_ADDRESS_MODE_REPEAT, VK_SAMPLER_MIPMAP_MODE_LINEAR);
@@ -227,7 +273,7 @@ public boolean swapchainOutOfDate(Swapchain swapchain, int imageAcquireCode) {
             long window = ((LwjglVulkanContext)context).getWindowHandle();
             try (SimpleSwapchainSupport support = new SimpleSwapchainSupport(device.getPhysicalDevice(), surface, window)) {
                 swapchain.reload(support);
-                swapchain.createFrameBuffers(renderPass);
+                swapchain.createFrameBuffers(renderPass, depthView);
             }
             return true;
         }
@@ -254,10 +300,11 @@ private GpuImage loadImage(String file, CommandPool transferPool) {
                     new BufferUsageFlags().transferSrc(), new MemoryFlags().hostVisible().hostCoherent(), false);
             staging.copy(stack, data.getBuffer());
             GpuImage image = new GpuImage(device, data.getWidth(), data.getHeight(), data.getFormat(),
-                    new ImageUsageFlags().transferDst().sampled(), new MemoryFlags().deviceLocal());
+                    Image.Tiling.Optimal, new ImageUsageFlags().transferDst().sampled(),
+                    new MemoryFlags().deviceLocal());
             CommandBuffer commands = transferPool.allocateOneTimeCommandBuffer();
             commands.begin();
-            image.transitionLayout(commands, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+            image.transitionLayout(commands, Image.Layout.Undefined, Image.Layout.TransferDstOptimal);
             VkBufferImageCopy.Buffer region = VkBufferImageCopy.calloc(1, stack)
                     .bufferOffset(0)
                     .bufferRowLength(0) // padding bytes
@@ -270,7 +317,7 @@ private GpuImage loadImage(String file, CommandPool transferPool) {
             region.imageExtent().set(data.getWidth(), data.getHeight(), 1);
             vkCmdCopyBufferToImage(commands.getBuffer(), staging.getNativeObject(),
                     image.getNativeObject(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, region);
-            image.transitionLayout(commands, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+            image.transitionLayout(commands, Image.Layout.TransferDstOptimal, Image.Layout.ShaderReadOnlyOptimal);
             commands.end();
             commands.submit(null, null, null);
             transferPool.getQueue().waitIdle();
diff --git a/jme3-lwjgl3/src/main/java/com/jme3/vulkan/GraphicsPipeline.java b/jme3-lwjgl3/src/main/java/com/jme3/vulkan/GraphicsPipeline.java
@@ -53,6 +53,13 @@ public GraphicsPipeline(LogicalDevice device, PipelineLayout layout, RenderPass
                     .sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO)
                     .pViewports(viewport)
                     .pScissors(scissor);
+            VkPipelineDepthStencilStateCreateInfo depthStencil = VkPipelineDepthStencilStateCreateInfo.calloc(stack)
+                    .sType(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO)
+                    .depthTestEnable(state.isDepthTest())
+                    .depthWriteEnable(state.isDepthWrite())
+                    .depthCompareOp(RenderStateToVulkan.depthFunc(state.getDepthFunc()))
+                    .depthBoundsTestEnable(false)
+                    .stencilTestEnable(false);
             VkPipelineRasterizationStateCreateInfo raster = VkPipelineRasterizationStateCreateInfo.calloc(stack)
                     .sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO)
                     .depthClampEnable(false)
@@ -89,6 +96,7 @@ public GraphicsPipeline(LogicalDevice device, PipelineLayout layout, RenderPass
                     .pVertexInputState(vertInput)
                     .pInputAssemblyState(assembly)
                     .pViewportState(vpState)
+                    .pDepthStencilState(depthStencil)
                     .pRasterizationState(raster)
                     .pMultisampleState(multisample)
                     .pColorBlendState(blend)
diff --git a/jme3-lwjgl3/src/main/java/com/jme3/vulkan/MeshDescription.java b/jme3-lwjgl3/src/main/java/com/jme3/vulkan/MeshDescription.java
@@ -17,22 +17,22 @@ public MeshDescription() {
         // for each vertex buffer on the mesh
         bindings = VkVertexInputBindingDescription.calloc(1)
                 .binding(0)
-                .stride(Float.BYTES * 7) // bytes per vertex
+                .stride(Float.BYTES * 8) // bytes per vertex
                 .inputRate(VK_VERTEX_INPUT_RATE_VERTEX);
         // for each attribute in each vertex buffer
         attributes = VkVertexInputAttributeDescription.calloc(3);
         attributes.get(0).binding(0)
                 .location(0)
-                .format(VK_FORMAT_R32G32_SFLOAT)
+                .format(VK_FORMAT_R32G32B32_SFLOAT)
                 .offset(0);
         attributes.get(1).binding(0)
                 .location(1)
                 .format(VK_FORMAT_R32G32B32_SFLOAT)
-                .offset(Float.BYTES * 2);
+                .offset(Float.BYTES * 3);
         attributes.get(2).binding(0)
                 .location(2)
                 .format(VK_FORMAT_R32G32_SFLOAT)
-                .offset(Float.BYTES * 5);
+                .offset(Float.BYTES * 6);
         ref = Native.get().register(this);
     }
 
diff --git a/jme3-lwjgl3/src/main/java/com/jme3/vulkan/PhysicalDevice.java b/jme3-lwjgl3/src/main/java/com/jme3/vulkan/PhysicalDevice.java
@@ -1,5 +1,6 @@
 package com.jme3.vulkan;
 
+import com.jme3.vulkan.images.Image;
 import org.lwjgl.PointerBuffer;
 import org.lwjgl.system.MemoryStack;
 import org.lwjgl.vulkan.*;
@@ -92,10 +93,10 @@ public int findMemoryType(MemoryStack stack, int types, int flags) {
         throw new NullPointerException("Suitable memory type not found.");
     }
 
-    public int findSupportedFormat(int tiling, int features, int... candidates) {
+    public Image.Format findSupportedFormat(int tiling, int features, Image.Format... candidates) {
         VkFormatProperties props = VkFormatProperties.create();
-        for (int f : candidates) {
-            vkGetPhysicalDeviceFormatProperties(device, f, props);
+        for (Image.Format f : candidates) {
+            vkGetPhysicalDeviceFormatProperties(device, f.getVkEnum(), props);
             if ((tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures() & features) == features)
                     || (tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures() & features) == features)) {
                 return f;
diff --git a/jme3-lwjgl3/src/main/java/com/jme3/vulkan/RenderPass.java b/jme3-lwjgl3/src/main/java/com/jme3/vulkan/RenderPass.java
@@ -53,8 +53,9 @@ public NativeReference getNativeReference() {
 
     public void begin(CommandBuffer cmd, FrameBuffer fbo) {
         try (MemoryStack stack = MemoryStack.stackPush()) {
-            VkClearValue.Buffer clear = VkClearValue.calloc(1, stack);
-            clear.color().float32(stack.floats(0f, 0f, 0f, 1f));
+            VkClearValue.Buffer clear = VkClearValue.calloc(2, stack);
+            clear.get(0).color().float32(stack.floats(0f, 0f, 0f, 1f));
+            clear.get(1).depthStencil().set(1.0f, 0);
             VkRenderPassBeginInfo begin = VkRenderPassBeginInfo.calloc(stack)
                     .sType(VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO)
                     .renderPass(id)
diff --git a/jme3-lwjgl3/src/main/java/com/jme3/vulkan/RenderStateToVulkan.java b/jme3-lwjgl3/src/main/java/com/jme3/vulkan/RenderStateToVulkan.java
@@ -9,6 +9,20 @@ private static RuntimeException unrecognized(Object state) {
         return new UnsupportedOperationException("Unrecognized: " + state);
     }
 
+    public static int depthFunc(TestFunction func) {
+        switch (func) {
+            case Always: return VK_COMPARE_OP_ALWAYS;
+            case Equal: return VK_COMPARE_OP_EQUAL;
+            case Greater: return VK_COMPARE_OP_GREATER;
+            case Less: return VK_COMPARE_OP_LESS;
+            case LessOrEqual: return VK_COMPARE_OP_LESS_OR_EQUAL;
+            case GreaterOrEqual: return VK_COMPARE_OP_GREATER_OR_EQUAL;
+            case Never: return VK_COMPARE_OP_NEVER;
+            case NotEqual: return VK_COMPARE_OP_NOT_EQUAL;
+            default: throw unrecognized(func);
+        }
+    }
+
     public static int blendEquation(BlendEquation eq) {
         switch (eq) {
             case Add: return VK_BLEND_OP_ADD;
diff --git a/jme3-lwjgl3/src/main/java/com/jme3/vulkan/Swapchain.java b/jme3-lwjgl3/src/main/java/com/jme3/vulkan/Swapchain.java
@@ -23,7 +23,7 @@ public class Swapchain implements Native<Long> {
     private final List<SwapchainImage> images = new ArrayList<>();
     private SwapchainUpdater updater;
     private Extent2 extent;
-    private int format;
+    private Image.Format format;
     private long id = VK_NULL_HANDLE;
 
     public Swapchain(LogicalDevice device, Surface surface, SwapchainSupport support) {
@@ -65,14 +65,14 @@ public void reload(SwapchainSupport support) {
             KHRSurface.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
                     device.getPhysicalDevice().getDevice(), surface.getNativeObject(), caps);
             VkSurfaceFormatKHR fmt = support.selectFormat();
-            format = fmt.format();
+            format = Image.Format.vkEnum(fmt.format());
             VkExtent2D ext = support.selectExtent();
             extent = new Extent2(ext);
             VkSwapchainCreateInfoKHR create = VkSwapchainCreateInfoKHR.calloc(stack)
                     .sType(KHRSwapchain.VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR)
                     .surface(surface.getNativeObject())
                     .minImageCount(support.selectImageCount())
-                    .imageFormat(format)
+                    .imageFormat(format.getVkEnum())
                     .imageColorSpace(fmt.colorSpace())
                     .imageExtent(ext)
                     .imageArrayLayers(1)
@@ -106,9 +106,9 @@ public void reload(SwapchainSupport support) {
         ref.refresh(); // refresh the native destroyer
     }
 
-    public void createFrameBuffers(RenderPass compat) {
+    public void createFrameBuffers(RenderPass compat, ImageView depthStencil) {
         for (SwapchainImage img : images) {
-            img.createFrameBuffer(compat);
+            img.createFrameBuffer(compat, depthStencil);
         }
     }
 
@@ -154,7 +154,7 @@ public Extent2 getExtent() {
         return extent;
     }
 
-    public int getFormat() {
+    public Image.Format getFormat() {
         return format;
     }
 
@@ -205,10 +205,15 @@ public int getDepth() {
         }
 
         @Override
-        public int getFormat() {
+        public Image.Format getFormat() {
             return format;
         }
 
+        @Override
+        public Image.Tiling getTiling() {
+            return Tiling.Optimal;
+        }
+
         @Override
         public Long getNativeObject() {
             return id;
@@ -227,8 +232,8 @@ public NativeReference getNativeReference() {
             return ref;
         }
 
-        public void createFrameBuffer(RenderPass compat) {
-            this.frameBuffer = new FrameBuffer(getDevice(), compat, extent.x, extent.y, 1, view);
+        public void createFrameBuffer(RenderPass compat, ImageView depthStencil) {
+            this.frameBuffer = new FrameBuffer(getDevice(), compat, extent.x, extent.y, 1, view, depthStencil);
         }
 
         public FrameBuffer getFrameBuffer() {
diff --git a/jme3-lwjgl3/src/main/java/com/jme3/vulkan/flags/ImageUsageFlags.java b/jme3-lwjgl3/src/main/java/com/jme3/vulkan/flags/ImageUsageFlags.java
@@ -21,6 +21,11 @@ public ImageUsageFlags sampled() {
         return this;
     }
 
+    public ImageUsageFlags depthStencilAttachment() {
+        usageFlags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+        return this;
+    }
+
     public int getUsageFlags() {
         return usageFlags;
     }
diff --git a/jme3-lwjgl3/src/main/java/com/jme3/vulkan/images/GpuImage.java b/jme3-lwjgl3/src/main/java/com/jme3/vulkan/images/GpuImage.java
diff --git a/jme3-lwjgl3/src/main/java/com/jme3/vulkan/images/Image.java b/jme3-lwjgl3/src/main/java/com/jme3/vulkan/images/Image.java
diff --git a/jme3-lwjgl3/src/main/java/com/jme3/vulkan/images/VulkanImageLoader.java b/jme3-lwjgl3/src/main/java/com/jme3/vulkan/images/VulkanImageLoader.java
diff --git a/jme3-testdata/src/main/resources/Shaders/VulkanVertTest.glsl b/jme3-testdata/src/main/resources/Shaders/VulkanVertTest.glsl

Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,11 @@ public ImageUsageFlags sampled() {`
`21`	`21`	`return this;`
`22`	`22`	`}`
`23`	`23`
	`24`	`+ public ImageUsageFlags depthStencilAttachment() {`
	`25`	`+ usageFlags \|= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;`
	`26`	`+ return this;`
	`27`	`+ }`
	`28`	`+`
`24`	`29`	`public int getUsageFlags() {`
`25`	`30`	`return usageFlags;`
`26`	`31`	`}`