split Vulkan and OpenGL APIs on GeometryBatch

Author: codex128

jme3-core/src/main/java/com/jme3/light/DefaultLightFilter.java

@@ -63,10 +63,9 @@ public void setCamera(Camera camera) {
     }
 
     @Override
-    public void filterLights(Geometry geometry, LightList filteredLightList) {
+    public void filterLights(Geometry geometry, LightList worldLights, LightList filteredLightList) {
         TempVars vars = TempVars.get();
         try {
-            LightList worldLights = geometry.getWorldLightList();
 
             for (int i = 0; i < worldLights.size(); i++) {
                 Light light = worldLights.get(i);

jme3-core/src/main/java/com/jme3/light/LightFilter.java

@@ -44,11 +44,11 @@ public interface LightFilter {
 
     /**
      * Sets the camera for which future filtering is to be done against in
-     * {@link #filterLights(com.jme3.scene.Geometry, com.jme3.light.LightList)}.
+     * {@link #filterLights(com.jme3.scene.Geometry, com.jme3.light.LightList, com.jme3.light.LightList)}.
      * 
      * @param camera The camera to perform light filtering against.
      */
-    public void setCamera(Camera camera);
+    void setCamera(Camera camera);
 
     /**
      * Determine which lights on the {@link Geometry#getWorldLightList() world
@@ -68,5 +68,5 @@ public interface LightFilter {
      * @param geometry The geometry for which the light filtering is performed.
      * @param filteredLightList The results are to be stored here. 
      */
-    public void filterLights(Geometry geometry, LightList filteredLightList);
+    void filterLights(Geometry geometry, LightList lights, LightList filteredLightList);
 }

jme3-core/src/main/java/com/jme3/light/NullLightFilter.java

@@ -47,7 +47,8 @@ public void setCamera(Camera camera) {
     }
 
     @Override
-    public void filterLights(Geometry geometry, LightList filteredLightList) {
+    public void filterLights(Geometry geometry, LightList lights, LightList filteredLightList) {
 
     }
+
 }

jme3-core/src/main/java/com/jme3/material/GlMaterial.java

@@ -54,6 +54,7 @@
 import com.jme3.renderer.TextureUnitException;
 import com.jme3.renderer.queue.RenderQueue.Bucket;
 import com.jme3.scene.Geometry;
+import com.jme3.scene.GlMesh;
 import com.jme3.shader.*;
 import com.jme3.shader.bufferobject.BufferObject;
 import com.jme3.texture.*;
@@ -64,7 +65,6 @@
 import com.jme3.vulkan.commands.CommandBuffer;
 import com.jme3.vulkan.frames.VersionedResource;
 import com.jme3.vulkan.pipelines.Pipeline;
-import org.lwjgl.opengl.GL45;
 
 import java.io.IOException;
 import java.util.Collection;
@@ -837,7 +837,15 @@ public void setVector4(String name, Vector4f value) {
      * @throws UnsupportedOperationException If no candidate technique supports
      * the system capabilities.
      */
-    public void selectTechnique(String name, final RenderManager renderManager) {
+    public Technique selectTechnique(String name, final RenderManager renderManager) {
+        // if null, use the currently selected technique, or the default technique
+        if (name == null || technique == null) {
+            if (technique != null) {
+                return technique;
+            } else {
+                name = TechniqueDef.DEFAULT_TECHNIQUE_NAME;
+            }
+        }
         // check if already created
         Technique tech = techniques.get(name);
         // When choosing technique, we choose one that
@@ -876,14 +884,16 @@ public void selectTechnique(String name, final RenderManager renderManager) {
         } else if (technique == tech) {
             // attempting to switch to an already
             // active technique.
-            return;
+            return technique;
         }
 
         technique = tech;
         tech.notifyTechniqueSwitched();
 
         // shader was changed
         sortingId = -1;
+
+        return technique;
     }
 
     private void applyOverrides(Renderer renderer, Shader shader, SafeArrayList<MatParamOverride> overrides, BindUnits bindUnits) {
@@ -947,8 +957,9 @@ private void updateShaderMaterialParameter(Renderer renderer, VarType type, Shad
         }
     }
 
-    private BindUnits updateShaderMaterialParameters(Renderer renderer, Shader shader,
-                                                     SafeArrayList<MatParamOverride> worldOverrides, SafeArrayList<MatParamOverride> forcedOverrides) {
+    public BindUnits updateShaderMaterialParameters(Renderer renderer, Shader shader,
+                                                     SafeArrayList<MatParamOverride> worldOverrides,
+                                                     SafeArrayList<MatParamOverride> forcedOverrides) {
 
         bindUnits.textureUnit = 0;
         bindUnits.bufferUnit = 0;
@@ -1015,6 +1026,7 @@ private boolean isNormalsBackward(Vector3f scalar) {
      * @param renderManager The render manager to preload for
      * @param geometry to determine the applicable parameter overrides, if any
      */
+    @Deprecated // this isn't used anywhere...
     public void preload(RenderManager renderManager, Geometry geometry) {
         if (technique == null) {
             selectTechnique(TechniqueDef.DEFAULT_TECHNIQUE_NAME, renderManager);
@@ -1153,7 +1165,7 @@ public void render(Geometry geometry, LightList lights, RenderManager renderMana
         resetUniformsNotSetByCurrent(shader);
 
         // Delegate rendering to the technique
-        technique.render(renderManager, shader, geometry, lights, units);
+        technique.render(renderManager, shader, geometry, (GlMesh)geometry.getMesh(), lights, units);
     }
 
     @Override

jme3-core/src/main/java/com/jme3/material/Material.java

@@ -36,12 +36,14 @@
 import com.jme3.math.*;
 import com.jme3.renderer.RenderManager;
 import com.jme3.scene.Geometry;
+import com.jme3.scene.Mesh;
 import com.jme3.texture.Texture;
 import com.jme3.vulkan.buffers.GpuBuffer;
 import com.jme3.vulkan.commands.CommandBuffer;
 import com.jme3.vulkan.frames.SingleResource;
 import com.jme3.vulkan.frames.VersionedResource;
 import com.jme3.vulkan.pipelines.Pipeline;
+import com.jme3.vulkan.pipelines.PipelineCache;
 
 /**
  * <code>Material</code> describes the rendering style for a given
@@ -58,24 +60,12 @@ public interface Material extends Savable {
 
     String DEFAULT_UNIFORM_BUFFER = "DefaultUniformBuffer";
 
-    void render(Geometry geometry, LightList lights, RenderManager renderManager);
-
-    void render(Geometry geometry, LightList lights, CommandBuffer cmd, Pipeline pipeline);
-
     void setUniform(String name, VersionedResource<? extends GpuBuffer> buffer);
 
     void setTexture(String name, VersionedResource<? extends Texture> texture);
 
     void setParam(String uniform, String param, Object value);
 
-    default void render(Geometry geometry, RenderManager renderManager) {
-        render(geometry, geometry.getWorldLightList(), renderManager);
-    }
-
-    default void render(Geometry geometry, CommandBuffer cmd, Pipeline pipeline) {
-        render(geometry, geometry.getWorldLightList(), cmd, pipeline);
-    }
-
     /* ----- COMPATABILITY WITH OLD MATERIAL ----- */
 
     default void setParam(String param, Object value) {

jme3-core/src/main/java/com/jme3/material/Technique.java

@@ -39,6 +39,7 @@
 import com.jme3.renderer.Caps;
 import com.jme3.renderer.RenderManager;
 import com.jme3.scene.Geometry;
+import com.jme3.scene.GlMesh;
 import com.jme3.shader.DefineList;
 import com.jme3.shader.Shader;
 import com.jme3.shader.VarType;
@@ -134,7 +135,7 @@ private void applyOverrides(DefineList defineList, SafeArrayList<MatParamOverrid
      * @param rendererCaps The renderer capabilities which the shader should support.
      * @return A compatible shader.
      */
-    Shader makeCurrent(RenderManager renderManager, SafeArrayList<MatParamOverride> worldOverrides,
+    public Shader makeCurrent(RenderManager renderManager, SafeArrayList<MatParamOverride> worldOverrides,
             SafeArrayList<MatParamOverride> forcedOverrides,
             LightList lights, EnumSet<Caps> rendererCaps) {
         TechniqueDefLogic logic = def.getLogic();
@@ -155,17 +156,18 @@ Shader makeCurrent(RenderManager renderManager, SafeArrayList<MatParamOverride>
 
     /**
      * Render the technique according to its {@link TechniqueDefLogic}.
-     * 
+     *
      * @param renderManager The render manager to perform the rendering against.
-     * @param shader The shader that was selected in 
-     * {@link #makeCurrent(RenderManager, SafeArrayList, SafeArrayList, LightList, EnumSet)}.
-     * @param geometry The geometry to render
-     * @param lights Lights which influence the geometry.
+     * @param shader        The shader that was selected in
+     *                      {@link #makeCurrent(RenderManager, SafeArrayList, SafeArrayList, LightList, EnumSet)}.
+     * @param geometry      The geometry to render
+     * @param mesh          The mesh to render
+     * @param lights        Lights which influence the geometry.
      * @param lastBindUnits the index of the most recently used texture unit
      */
-    void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, BindUnits lastBindUnits) {
+    public void render(RenderManager renderManager, Shader shader, Geometry geometry, GlMesh mesh, LightList lights, BindUnits lastBindUnits) {
         TechniqueDefLogic logic = def.getLogic();
-        logic.render(renderManager, shader, geometry, lights, lastBindUnits);
+        logic.render(renderManager, shader, geometry, mesh, lights, lastBindUnits);
     }
 
     /**

jme3-core/src/main/java/com/jme3/material/logic/DefaultTechniqueDefLogic.java

@@ -40,6 +40,9 @@
 import com.jme3.renderer.RenderManager;
 import com.jme3.renderer.Renderer;
 import com.jme3.scene.Geometry;
+import com.jme3.scene.GlMesh;
+import com.jme3.scene.Mesh;
+import com.jme3.scene.instancing.InstancedGeometry;
 import com.jme3.shader.DefineList;
 import com.jme3.shader.Shader;
 import java.util.EnumSet;
@@ -58,8 +61,17 @@ public Shader makeCurrent(AssetManager assetManager, RenderManager renderManager
         return techniqueDef.getShader(assetManager, rendererCaps, defines);
     }
 
-    public static void renderMeshFromGeometry(Renderer renderer, Geometry geom) {
-        geom.draw(renderer);
+    public static void renderMeshFromGeometry(Renderer renderer, Geometry geom, GlMesh mesh) {
+        int lodLevel = geom.getLodLevel();
+        if (geom instanceof InstancedGeometry) {
+            InstancedGeometry instGeom = (InstancedGeometry) geom;
+            int numVisibleInstances = instGeom.getNumVisibleInstances();
+            if (numVisibleInstances > 0) {
+                renderer.renderMesh(mesh, lodLevel, numVisibleInstances, instGeom.getAllInstanceData());
+            }
+        } else {
+            renderer.renderMesh(mesh, lodLevel, 1, null);
+        }
     }
 
     protected static ColorRGBA getAmbientColor(LightList lightList, boolean removeLights, ColorRGBA ambientLightColor) {
@@ -80,9 +92,9 @@ protected static ColorRGBA getAmbientColor(LightList lightList, boolean removeLi
 
 
     @Override
-    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, GlMaterial.BindUnits lastBindUnits) {
+    public void render(RenderManager renderManager, Shader shader, Geometry geometry, GlMesh mesh, LightList lights, GlMaterial.BindUnits lastBindUnits) {
         Renderer renderer = renderManager.getRenderer();
         renderer.setShader(shader);
-        renderMeshFromGeometry(renderer, geometry);
+        renderMeshFromGeometry(renderer, geometry, mesh);
     }
 }

jme3-core/src/main/java/com/jme3/material/logic/MultiPassLightingLogic.java

@@ -46,6 +46,7 @@
 import com.jme3.renderer.RenderManager;
 import com.jme3.renderer.Renderer;
 import com.jme3.scene.Geometry;
+import com.jme3.scene.GlMesh;
 import com.jme3.shader.Shader;
 import com.jme3.shader.Uniform;
 import com.jme3.shader.VarType;
@@ -68,7 +69,7 @@ public MultiPassLightingLogic(TechniqueDef techniqueDef) {
     }
 
     @Override
-    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, GlMaterial.BindUnits lastBindUnits) {
+    public void render(RenderManager renderManager, Shader shader, Geometry geometry, GlMesh mesh, LightList lights, GlMaterial.BindUnits lastBindUnits) {
         Renderer r = renderManager.getRenderer();
         Uniform lightDir = shader.getUniform("g_LightDirection");
         Uniform lightColor = shader.getUniform("g_LightColor");
@@ -157,7 +158,7 @@ public void render(RenderManager renderManager, Shader shader, Geometry geometry
             }
             vars.release();
             r.setShader(shader);
-            renderMeshFromGeometry(r, geometry);
+            renderMeshFromGeometry(r, geometry, mesh);
         }
 
         if (isFirstLight) {
@@ -167,7 +168,7 @@ public void render(RenderManager renderManager, Shader shader, Geometry geometry
             lightColor.setValue(VarType.Vector4, ColorRGBA.BlackNoAlpha);
             lightPos.setValue(VarType.Vector4, NULL_DIR_LIGHT);
             r.setShader(shader);
-            renderMeshFromGeometry(r, geometry);
+            renderMeshFromGeometry(r, geometry, mesh);
         }
     }
 }

jme3-core/src/main/java/com/jme3/material/logic/SinglePassAndImageBasedLightingLogic.java

@@ -38,6 +38,7 @@
 import com.jme3.math.*;
 import com.jme3.renderer.*;
 import com.jme3.scene.Geometry;
+import com.jme3.scene.GlMesh;
 import com.jme3.shader.*;
 import com.jme3.texture.TextureCubeMap;
 import com.jme3.util.TempVars;
@@ -107,15 +108,14 @@ public Shader makeCurrent(AssetManager assetManager, RenderManager renderManager
      * attenuation) </p>
      *
      * @param shader the Shader being used
-     * @param g the Geometry being rendered
      * @param lightList the list of lights
      * @param numLights the number of lights to upload
      * @param rm to manage rendering
      * @param startIndex the starting index in the LightList
      * @param lastTexUnit the index of the most recently-used texture unit
      * @return the next starting index in the LightList
      */
-    protected int updateLightListUniforms(Shader shader, Geometry g, LightList lightList, int numLights, RenderManager rm, int startIndex, int lastTexUnit) {
+    private int updateLightListUniforms(Shader shader, LightList lightList, int numLights, RenderManager rm, int startIndex, int lastTexUnit) {
         if (numLights == 0) { // this shader does not do lighting, ignore.
             return 0;
         }
@@ -262,24 +262,24 @@ private int setProbeData(RenderManager rm, int lastTexUnit, Uniform lightProbeDa
     }
 
     @Override
-    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, GlMaterial.BindUnits lastBindUnits) {
+    public void render(RenderManager renderManager, Shader shader, Geometry geometry, GlMesh mesh, LightList lights, GlMaterial.BindUnits lastBindUnits) {
         int nbRenderedLights = 0;
         Renderer renderer = renderManager.getRenderer();
         int batchSize = renderManager.getSinglePassLightBatchSize();
         if (lights.size() == 0) {
-            updateLightListUniforms(shader, geometry, lights, batchSize, renderManager, 0, lastBindUnits.textureUnit);
+            updateLightListUniforms(shader, lights, batchSize, renderManager, 0, lastBindUnits.textureUnit);
             renderer.setShader(shader);
-            renderMeshFromGeometry(renderer, geometry);
+            renderMeshFromGeometry(renderer, geometry, mesh);
         } else {
             while (nbRenderedLights < lights.size()) {
-                nbRenderedLights = updateLightListUniforms(shader, geometry, lights, batchSize, renderManager, nbRenderedLights, lastBindUnits.textureUnit);
+                nbRenderedLights = updateLightListUniforms(shader, lights, batchSize, renderManager, nbRenderedLights, lastBindUnits.textureUnit);
                 renderer.setShader(shader);
-                renderMeshFromGeometry(renderer, geometry);
+                renderMeshFromGeometry(renderer, geometry, mesh);
             }
         }
     }
 
-    protected void extractIndirectLights(LightList lightList, boolean removeLights) {
+    private void extractIndirectLights(LightList lightList, boolean removeLights) {
         ambientLightColor.set(0, 0, 0, 1);
         useAmbientLight = false;
         for (int j = 0; j < lightList.size(); j++) {

jme3-core/src/main/java/com/jme3/material/logic/SinglePassLightingLogic.java

@@ -48,6 +48,7 @@
 import com.jme3.renderer.RenderManager;
 import com.jme3.renderer.Renderer;
 import com.jme3.scene.Geometry;
+import com.jme3.scene.GlMesh;
 import com.jme3.shader.DefineList;
 import com.jme3.shader.Shader;
 import com.jme3.shader.Uniform;
@@ -99,14 +100,13 @@ public Shader makeCurrent(AssetManager assetManager, RenderManager renderManager
      * attenuation)</p>
      *
      * @param shader the Shader being used
-     * @param g the Geometry being rendered
      * @param lightList the list of lights
      * @param numLights the number of lights to upload
      * @param rm to manage rendering
      * @param startIndex the starting index in the LightList
      * @return the next starting index in the LightList
      */
-    protected int updateLightListUniforms(Shader shader, Geometry g, LightList lightList, int numLights, RenderManager rm, int startIndex) {
+    private int updateLightListUniforms(Shader shader, LightList lightList, int numLights, RenderManager rm, int startIndex) {
         if (numLights == 0) { // this shader does not do lighting, ignore.
             return 0;
         }
@@ -207,19 +207,19 @@ protected int updateLightListUniforms(Shader shader, Geometry g, LightList light
     }
 
     @Override
-    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, GlMaterial.BindUnits lastBindUnits) {
+    public void render(RenderManager renderManager, Shader shader, Geometry geometry, GlMesh mesh, LightList lights, GlMaterial.BindUnits lastBindUnits) {
         int nbRenderedLights = 0;
         Renderer renderer = renderManager.getRenderer();
         int batchSize = renderManager.getSinglePassLightBatchSize();
         if (lights.size() == 0) {
-            updateLightListUniforms(shader, geometry, lights, batchSize, renderManager, 0);
+            updateLightListUniforms(shader, lights, batchSize, renderManager, 0);
             renderer.setShader(shader);
-            renderMeshFromGeometry(renderer, geometry);
+            renderMeshFromGeometry(renderer, geometry, mesh);
         } else {
             while (nbRenderedLights < lights.size()) {
-                nbRenderedLights = updateLightListUniforms(shader, geometry, lights, batchSize, renderManager, nbRenderedLights);
+                nbRenderedLights = updateLightListUniforms(shader, lights, batchSize, renderManager, nbRenderedLights);
                 renderer.setShader(shader);
-                renderMeshFromGeometry(renderer, geometry);
+                renderMeshFromGeometry(renderer, geometry, mesh);
             }
         }
     }