trying to improve geometry batching and rendering

Author: codex128

jme3-core/src/main/java/com/jme3/backend/SimpleVulkanEngine.java

@@ -6,6 +6,7 @@
 import com.jme3.light.Light;
 import com.jme3.light.PointLight;
 import com.jme3.light.SpotLight;
+import com.jme3.material.Material;
 import com.jme3.material.RenderState;
 import com.jme3.material.plugins.VulkanMaterialLoader;
 import com.jme3.math.ColorRGBA;
@@ -53,15 +54,14 @@
 import com.jme3.vulkan.material.NewMaterialDef;
 import com.jme3.vulkan.material.VulkanMaterial;
 import com.jme3.vulkan.material.shader.ShaderModule;
+import com.jme3.vulkan.material.technique.NewTechnique;
+import com.jme3.vulkan.material.technique.VulkanTechnique;
 import com.jme3.vulkan.material.uniforms.TextureUniform;
 import com.jme3.vulkan.material.uniforms.Uniform;
 import com.jme3.vulkan.material.uniforms.StructUniform;
 import com.jme3.vulkan.memory.MemoryProp;
 import com.jme3.vulkan.memory.MemorySize;
-import com.jme3.vulkan.mesh.AdaptiveMesh;
-import com.jme3.vulkan.mesh.AdaptiveVertexBinding;
-import com.jme3.vulkan.mesh.InputRate;
-import com.jme3.vulkan.mesh.MeshLayout;
+import com.jme3.vulkan.mesh.*;
 import com.jme3.vulkan.mesh.attribute.*;
 import com.jme3.vulkan.pass.Attachment;
 import com.jme3.vulkan.pass.RenderPass;
@@ -71,6 +71,7 @@
 import com.jme3.vulkan.pipeline.framebuffer.FrameBuffer;
 import com.jme3.vulkan.pipeline.framebuffer.OutputFrameBuffer;
 import com.jme3.vulkan.pipeline.graphics.GraphicsPipeline;
+import com.jme3.vulkan.render.AbstractBatchElement;
 import com.jme3.vulkan.render.GeometryBatch;
 import com.jme3.vulkan.render.RenderEngine;
 import com.jme3.vulkan.render.VulkanGeometryBatch;
@@ -172,7 +173,11 @@ public static class Transforms implements Struct {
     private OutputFrameBuffer outFrameBuffer;
     private final BufferGenerator<VulkanBuffer> bufferGen = new BufferGeneratorImpl();
 
-    private VulkanGeometryBatch opaque, sky, transparent, gui, translucent;
+    private final GeometryBatch<Element> opaque = new GeometryBatch<>(new OpaqueComparator());
+    private final GeometryBatch<Element> sky = new GeometryBatch<>(new OpaqueComparator());
+    private final GeometryBatch<Element> transparent = new GeometryBatch<>(new TransparentComparator());
+    private final GeometryBatch<Element> gui = new GeometryBatch<>(new GuiComparator());
+    private final GeometryBatch<Element> translucent = new GeometryBatch<>(new TransparentComparator());
 
     private final Cache<Pipeline> pipelineCache = new Cache<>();
     private final Cache<PipelineLayout> pipelineLayoutCache = new Cache<>();
@@ -270,13 +275,7 @@ private void initialize() {
             }));
         });
 
-        opaque = new EngineGeometryBatch(new OpaqueComparator(), descriptorPool);
-        sky = new EngineGeometryBatch(new OpaqueComparator(), descriptorPool);
-        transparent = new EngineGeometryBatch(new TransparentComparator(), descriptorPool);
-        gui = new EngineGeometryBatch(new GuiComparator(), descriptorPool);
-        translucent = new EngineGeometryBatch(new TransparentComparator(), descriptorPool);
         outFrameBuffer = new OutputFrameBuffer(swapchain, renderPass);
-
         stream = new BufferStream(device, 500);
         for (int i = 0; i < framesInFlight.length; i++) {
             framesInFlight[i] = new Frame();
@@ -417,40 +416,38 @@ private void render(ViewPort vp) {
             for (Spatial scene : vp.getScenes()) for (Spatial.GraphIterator it = scene.iterator(cull, bucket); it.hasNext();) {
                 Spatial child = it.next();
                 child.runControlRender(SimpleVulkanEngine.this, vp);
-                if (cull.peek() != Camera.FrustumIntersect.Outside) {
-                    if (child instanceof Geometry) {
-                        Geometry g = (Geometry) child;
-                        if (vp.getGeometryFilter() == null || vp.getGeometryFilter().test(g)) {
-                            GeometryBatch<?> batch = getBatchByQueueBucket(bucket.peek());
-                            if (batch != null) {
-                                batch.add(g);
-                            }
+                if (cull.peek() == Camera.FrustumIntersect.Outside) {
+                    it.skipChildren();
+                } else if (child instanceof Geometry) {
+                    Geometry g = (Geometry)child;
+                    if (vp.getGeometryFilter() == null || vp.getGeometryFilter().test(g)) {
+                        GeometryBatch<?> batch = getBatchByQueueBucket(bucket.peek());
+                        if (batch != null) {
+                            batch.add(new Element(g, null, ));
                         }
                     }
-                } else {
-                    it.skipChildren();
                 }
             }
 
-            CommandSetting<ViewPortArea> vpArea = CommandSetting.viewPort();
-            CommandSetting<ScissorArea> scissor = CommandSetting.scissor();
+            CommandSetting<ViewPortArea> vpArea = graphics.addSetting(CommandSetting.viewPort());
+            CommandSetting<ScissorArea> scissor = graphics.addSetting(CommandSetting.scissor());
 
             vpArea.push(vp.getArea());
             scissor.push(vp.getArea().toScissor(null));
             {
-                opaque.render(graphics, vpArea, scissor);
+                renderBatch(opaque);
                 vpArea.push(vp.getArea().clone().toMaxDepth());
                 {
-                    sky.render(graphics, vpArea, scissor);
+                    renderBatch(sky);
                 }
                 vpArea.pop();
-                transparent.render(graphics, vpArea, scissor);
+                renderBatch(transparent);
                 vpArea.push(vp.getArea().clone().toMinDepth());
                 {
-                    gui.render(graphics, vpArea, scissor);
+                    renderBatch(gui);
                 }
                 vpArea.pop();
-                translucent.render(graphics, vpArea, scissor);
+                renderBatch(translucent);
             }
             vpArea.pop();
             scissor.pop();
@@ -464,67 +461,22 @@ private void render(ViewPort vp) {
 
         }
 
-        private GeometryBatch<?> getBatchByQueueBucket(RenderQueue.Bucket bucket) {
-            switch (bucket) {
-                case Opaque: return opaque;
-                case Sky: return sky;
-                case Transparent: return transparent;
-                case Gui: return gui;
-                case Translucent: return translucent;
-                default: return null;
-            }
-        }
-
-    }
-
-    private class EngineGeometryBatch extends VulkanGeometryBatch {
-
-        private final RenderState tempState = new RenderState();
-
-        public EngineGeometryBatch(Comparator<? super Element> comparator, DescriptorPool pool) {
-            super(comparator, pool);
-        }
-
-        @Override
-        protected VertexPipeline createPipeline(Element e) {
-            return GraphicsPipeline.build(device, p -> {
-                p.setCache(pipelineCache);
-                p.setLayoutCache(pipelineLayoutCache);
-                p.setShaderCache(shaderCache);
-                p.setSetLayoutCache(descSetLayoutCache);
-                p.setSubpass(renderPass.getSubpass(0));
-                p.setDynamic(DynamicState.ViewPort, true);
-                p.setDynamic(DynamicState.Scissor, true);
-                p.setDepthClamp(true);
-                p.applyGeometry(app.getAssetManager(), e.getMesh(), e.getMaterial(), e.getTechnique());
-                p.applyRenderState(tempState.integrateGeometryStates(e.getGeometry(), forcedRenderState,
-                        e.getMaterial().getAdditionalRenderState(), e.getTechnique().getRenderState()));
-            });
-        }
-
-        @Override
-        public void render(CommandBuffer cmd, Runnable onRender) {
-            if (onRender != null && !queue.isEmpty()) {
-                onRender.run();
+        private void renderBatch(GeometryBatch<Element> batch) {
+            if (batch.isEmpty()) {
+                return;
             }
-            transforms.viewProjectionMatrix.set(camera.getViewProjectionMatrix());
+            graphics.applySettings();
             VertexPipeline currentPipeline = null;
             VulkanMaterial currentMaterial = null;
             TempVars vars = TempVars.get();
-            for (Element e : queue) {
-
-                // bind pipeline if necessary
+            for (Element e : batch) {
                 if (e.getPipeline() != currentPipeline) {
-                    (currentPipeline = e.getPipeline()).bind(cmd);
+                    (currentPipeline = e.getPipeline()).bind(graphics);
                     currentMaterial = null;
                 }
-
-                // bind material if necessary
                 if (e.getMaterial() != currentMaterial) {
-                    (currentMaterial = e.getMaterial()).bind(cmd, currentPipeline, descriptorPool);
+                    (currentMaterial = e.getMaterial()).bind(graphics, currentPipeline, descriptorPool);
                 }
-
-                // find light indices
                 lighting.indices.clear();
                 int lightIndex = 0;
                 for (LightData l : lighting.lights) {
@@ -533,17 +485,26 @@ public void render(CommandBuffer cmd, Runnable onRender) {
                     }
                     lightIndex++;
                 }
-
                 transforms.viewProjectionMatrix.mult(e.getGeometry().getWorldMatrix(), transforms.worldViewProjectionMatrix);
                 currentMaterial.set("Lighting", lighting);
                 currentMaterial.set("Transforms", transforms);
-                stream.stream(cmd);
-
-                // render
-                e.getMesh().render(cmd, currentPipeline);
+                stream.stream(graphics); // this is a problem
+                e.getMesh().render(graphics, e.getPipeline());
             }
             vars.release();
         }
+
+        private GeometryBatch<?> getBatchByQueueBucket(RenderQueue.Bucket bucket) {
+            switch (bucket) {
+                case Opaque: return opaque;
+                case Sky: return sky;
+                case Transparent: return transparent;
+                case Gui: return gui;
+                case Translucent: return translucent;
+                default: return null;
+            }
+        }
+
     }
 
     private class SwapchainUpdater implements Consumer<Swapchain> {
@@ -584,4 +545,75 @@ public VulkanBuffer createBuffer(MemorySize size, Flag<BufferUsage> bufUsage, Gl
 
     }
 
+    private class Element extends AbstractBatchElement {
+
+        private final VulkanTechnique technique;
+        private final VulkanMaterial material;
+        private final VulkanMesh mesh;
+        private final VertexPipeline pipeline;
+
+        private Element(Geometry geometry, RenderState forcedRenderState,
+                        Material forcedMaterial, String forcedTechnique, Mesh forcedMesh) {
+            super(geometry);
+            Material mat = forcedMaterial != null ? forcedMaterial : geometry.getMaterial();
+            if (!(mat instanceof NewMaterial)) {
+                throw new ClassCastException("Cannot render " + mat.getClass() + " in a Vulkan context.");
+            }
+            this.material = (VulkanMaterial)mat;
+            this.technique = material.getTechnique(forcedTechnique != null ? forcedTechnique : "main");
+            Mesh mesh = forcedMesh != null ? forcedMesh : geometry.getMesh();
+            if (!(mesh instanceof VulkanMesh)) {
+                throw new ClassCastException("Cannot render " + mesh.getClass() + " in a Vulkan context.");
+            }
+            this.mesh = (VulkanMesh)mesh;
+            this.pipeline = GraphicsPipeline.build(device, p -> {
+                p.setCache(pipelineCache);
+                p.setLayoutCache(pipelineLayoutCache);
+                p.setShaderCache(shaderCache);
+                p.setSetLayoutCache(descSetLayoutCache);
+                p.setSubpass(renderPass.getSubpass(0));
+                p.setDynamic(DynamicState.ViewPort, true);
+                p.setDynamic(DynamicState.Scissor, true);
+                p.setDepthClamp(true);
+                p.applyGeometry(app.getAssetManager(), this.mesh, this.material, this.technique);
+                p.applyRenderState(new RenderState().integrateGeometryStates(geometry, forcedRenderState,
+                        this.material.getAdditionalRenderState(), this.technique.getRenderState()));
+            });
+        }
+
+        @Override
+        public Camera getCamera() {
+            return VulkanGeometryBatch.this.getCamera();
+        }
+
+        @Override
+        public VulkanMaterial getMaterial() {
+            return material;
+        }
+
+        @Override
+        public VulkanMesh getMesh() {
+            return mesh;
+        }
+
+        @Override
+        public long getPipelineSortId() {
+            return pipeline.getSortId();
+        }
+
+        @Override
+        public long getMaterialSortId() {
+            return 0;
+        }
+
+        public VulkanTechnique getTechnique() {
+            return technique;
+        }
+
+        public VertexPipeline getPipeline() {
+            return pipeline;
+        }
+
+    }
+
 }

jme3-core/src/main/java/com/jme3/util/struct/StructLayout.java

@@ -322,9 +322,25 @@ public void updateBuffer(Struct src, BufferMapping dst, boolean force) {
         }
     }
 
+    public void updateBuffer(Struct src, BufferMapping dst, String... fieldNames) {
+        updateBuffer(src, dst, false, fieldNames);
+    }
+
+    public void updateBuffer(Struct src, BufferMapping dst, boolean force, String... fieldNames) {
+        try {
+            int p = dst.getBytes().position();
+            getFieldDescription(src.getClass()).write(this, dst, src, force, fieldNames);
+            dst.getBytes().position(p);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException("Failed to update buffer.", e);
+        }
+    }
+
     public void updateStruct(ByteBuffer src, Struct dst) {
         try {
+            int p = src.position();
             getFieldDescription(dst.getClass()).read(this, src, dst);
+            src.position(p);
         } catch (IllegalAccessException e) {
             throw new RuntimeException("Failed to update struct.", e);
         }
@@ -388,6 +404,10 @@ public interface FieldDesc <T> {
 
         T read(StructLayout layout, ByteBuffer buffer, T value) throws IllegalAccessException;
 
+        default void write(StructLayout layout, BufferMapping mapping, T value, boolean force, String... fieldNames) throws IllegalAccessException {
+            write(layout, mapping, value, force);
+        }
+
     }
 
     public static class StructDesc implements FieldDesc<Struct> {
@@ -417,6 +437,18 @@ public void write(StructLayout layout, BufferMapping mapping, Struct value, bool
             alignBuffer(mapping.getBytes(), info.getAlignment());
         }
 
+        @Override
+        public void write(StructLayout layout, BufferMapping mapping, Struct value, boolean force, String... fieldNames) throws IllegalAccessException {
+            StructInfo info = layout.getStructInfo(value.getClass());
+            alignBuffer(mapping.getBytes(), info.getAlignment());
+            for (Field f : info.getFields()) {
+                if (Arrays.stream(fieldNames).anyMatch(n -> n.equals(f.getName()))) {
+                    layout.getFieldDescription(f.getType()).write(layout, mapping, f.get(value), force);
+                }
+            }
+            alignBuffer(mapping.getBytes(), info.getAlignment());
+        }
+
         @Override
         public Struct read(StructLayout layout, ByteBuffer buffer, Struct value) throws IllegalAccessException {
             StructInfo info = layout.getStructInfo(value.getClass());

jme3-core/src/main/java/com/jme3/vulkan/commands/CommandBuffer.java

@@ -200,6 +200,15 @@ public void reset() {
         completionListeners.clear();
     }
 
+    public <T extends CommandSetting> T addSetting(T setting) {
+        // add setting
+        return setting;
+    }
+
+    public void applySettings() {
+        // apply settings
+    }
+
     /**
      * Registers a semaphore to be signaled when the command buffer finishes
      * execution. All registered signal semaphores are removed when this