experiment with material parameter handling

Author: codex128

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

@@ -87,12 +87,13 @@ public void bind(Struct struct) {
      *
      * @param layout layout
      */
-    public void bind(StructLayout layout) {
+    public <E extends Struct> E bind(StructLayout layout) {
         if (this.layout == layout) {
-            return;
+            return (E)this;
         }
         this.layout = layout;
         computeOffsets();
+        return (E)this;
     }
 
     /**

jme3-core/src/main/java/com/jme3/vulkan/material/experimental/Unlit.java

@@ -2,65 +2,53 @@
 
 import com.jme3.math.ColorRGBA;
 import com.jme3.texture.Texture;
+import com.jme3.util.struct.Struct;
 import com.jme3.util.struct.StructLayout;
 import com.jme3.util.struct.StructMapping;
-import com.jme3.vulkan.descriptors.CachedDescriptorSet;
-import com.jme3.vulkan.descriptors.DescriptorPool;
-import com.jme3.vulkan.descriptors.DescriptorSetLayout;
+import com.jme3.vulkan.JmePlatform;
+import com.jme3.vulkan.buffers.BufferUsage;
+import com.jme3.vulkan.buffers.MappableBuffer;
+import com.jme3.vulkan.buffers.saving.UpdateHint;
 import com.jme3.vulkan.material.structs.UnshadedParams;
-import com.jme3.vulkan.pipeline.PipelineLayout;
+import com.jme3.vulkan.util.Flag;
 
+import java.util.HashMap;
 import java.util.IdentityHashMap;
 import java.util.Map;
 
-public class Unlit implements ShaderInterface {
+public class Unlit {
 
-    private final Map<DescriptorSetLayout, CachedDescriptorSet> sets = new IdentityHashMap<>();
-    private final UnshadedParams params = new UnshadedParams();
+    private final Map<String, Object> parameters = new HashMap<>();
+    private final Map<MappableBuffer, StructMapping> mappings = new IdentityHashMap<>();
+    private final MappableBuffer visualBuffer = JmePlatform.allocateStandardBuffer(1, BufferUsage.Uniform, UpdateHint.Dynamic);
+    private final UnshadedParams visuals = new UnshadedParams();
 
     {
-        params.bind(StructLayout.std140);
+        visuals.bind(StructLayout.std140);
+        visualBuffer.resize(visuals.getSize());
     }
 
-    public void update(PipelineLayout pipeline, DescriptorPool pool, ParameterPool parameters) {
-        pipeline.allocate(pool, sets);
-        pipeline.write(sets, "ColorMap", parameters.get("ColorMap"));
-        try (StructMapping<UnshadedParams> m = parameters.mapBuffer("Params", params)) {
-            params.color.compareAndSet(parameters.get("Color"));
+    protected <T extends Struct> T map(MappableBuffer buffer, T struct) {
+        StructMapping<T> map = mappings.get(buffer);
+        if (map == null) {
+            mappings.put(buffer, map = buffer.mapStruct(struct));
         }
+        return map.get();
     }
 
-    @Override
-    public void close() {
-
-    }
-
-    protected UnshadedParams getUnshaded() {
-        return getStruct("Unshaded", UnshadedParams::new, StructLayout.std140);
-    }
-
-    public void setBaseColor(ColorRGBA color) {
-        getUnshaded().color.set(color);
+    public void flush() {
+        for (StructMapping m : mappings.values()) {
+            m.close();
+        }
+        mappings.clear();
     }
 
-    public void setVertexColor(boolean vertexColor) {
-        getUnshaded().vertexColor.set(true);
+    public void setColor(ColorRGBA color) {
+        map(visualBuffer, visuals).color.set(color);
     }
 
     public void setColorMap(Texture texture) {
         parameters.put("ColorMap", texture);
     }
 
-    public ColorRGBA getBaseColor() {
-        return getUnshaded().color.get();
-    }
-
-    public boolean isVertexColor() {
-        return getUnshaded().vertexColor.get();
-    }
-
-    public Texture getColorMap() {
-        return (Texture)parameters.get("ColorMap");
-    }
-
 }

jme3-core/src/main/java/com/jme3/vulkan/material/experimental/UnshadedRenderer.java

@@ -0,0 +1,43 @@
+package com.jme3.vulkan.material.experimental;
+
+import com.jme3.material.Material;
+import com.jme3.vulkan.buffers.MappableBuffer;
+import com.jme3.vulkan.buffers.saving.UpdateHint;
+import com.jme3.vulkan.material.structs.UnshadedParams;
+
+import java.util.List;
+
+public class UnshadedRenderer {
+
+    public void render(Material material) {
+        /*
+        There are 2 types of buffers:
+            1. Buffers that are local to a material. Their contents don't change often
+               so it's best to use more memory per material and keep their contents on the gpu.
+            2. Buffers that are local to the renderer. Their contents change often, so it's
+               best to save memory and use the same buffer for every material.
+            3. Buffers that are shared among multiple renderers. Their content changes often,
+               and renderers are likely to be using the same buffer layout.
+        How do we identify which buffers fall into which category?
+            1. Have the user/shader specify an update hint. For the camera buffer, this would
+               be specified by the shader. For random stuff the user happens to want to update
+               often, the hint would be specified by the user.
+            2. For renderer-local and renderer-global buffers, I think these concepts can be
+               merged into one, since the only difference is the formatting. The format can be
+               identified via the struct type. So the renderer manager will store all renderer
+               buffers by the struct used on them.
+        Next, a buffer is a collection of parameters. How does the user specify the update
+        hint when the user only has access to individual parameters?
+            1. Treat as renderer managed if at least one hint is Stream.
+            2. Treat as renderer managed if a majority of hints are Stream.
+            3. Treat as renderer managed if all hints are Stream.
+        */
+        UpdateHint hint = material.getParameter("Color").getUpdateHint();
+        if (hint == UpdateHint.Stream) {
+            MappableBuffer buffer = manager.getBuffer(new UnshadedParams());
+        } else {
+            MappableBuffer buffer = material.getBuffer(getClass(), new UnshadedParams());
+        }
+    }
+
+}

jme3-examples/src/main/java/jme3test/vulkan/TestJme4.java

@@ -13,9 +13,11 @@
 import com.jme3.renderer.queue.TransparentComparator;
 import com.jme3.scene.Geometry;
 import com.jme3.scene.shape.Box;
+import com.jme3.util.struct.StructMapping;
 import com.jme3.vulkan.commands.StandardRenderSettings;
 import com.jme3.vulkan.material.NewMaterial;
 import com.jme3.vulkan.material.experimental.Unlit;
+import com.jme3.vulkan.material.structs.UnshadedParams;
 import com.jme3.vulkan.render.bucket.GeometryBucket;
 import com.sun.tools.javac.util.List;
 
@@ -35,10 +37,10 @@ public void simpleInitApp() {
 
         Geometry g = new Geometry("geom_jme4", new Box(1f, 1f, 1f));
         NewMaterial mat = (NewMaterial)engine.createMaterial("Common/MatDefs/Misc/Unshaded.j3md");
-        try (Unlit u = new Unlit()) {
-            u.setBaseColor(ColorRGBA.White);
-            u.setColorMap(null);
+        try (StructMapping<UnshadedParams> m = mat.getInterface(Unlit.class).mapVisuals()) {
+            m.get().color.set(ColorRGBA.Blue);
         }
+        mat.getInterface(Unlit.class).setColorMap(myTexture);
         g.setMaterial(mat);
         rootNode.attachChild(g);