Improved UBO/SSBO implementation

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

@@ -501,6 +501,18 @@ public void setParam(String name, VarType type, Object value) {
         }
     }
 
+      /**
+     * Pass a parameter to the material shader. The VarType will be obtained from the matdef.
+     *
+     * @param name the name of the parameter defined in the material definition (j3md)
+     * @param value the value of the parameter
+     */
+    public void setParam(String name,  Object value) {
+        MatParam p=getMaterialDef().getMaterialParam(name);
+        setParam(name,p.getVarType(),value);
+    }
+
+
     /**
      * Clear a parameter from this material. The parameter must exist
      * @param name the name of the parameter to clear
@@ -678,8 +690,7 @@ public void setColor(String name, ColorRGBA value) {
      * @param value the buffer object.
      */
     public void setUniformBufferObject(final String name, final BufferObject value) {
-        value.setBufferType(BufferObject.BufferType.UniformBufferObject);
-        setParam(name, VarType.BufferObject, value);
+        setParam(name, VarType.UniformBufferObject, value);
     }
 
     /**
@@ -689,8 +700,7 @@ public void setUniformBufferObject(final String name, final BufferObject value)
      * @param value the buffer object.
      */
     public void setShaderStorageBufferObject(final String name, final BufferObject value) {
-        value.setBufferType(BufferObject.BufferType.ShaderStorageBufferObject);
-        setParam(name, VarType.BufferObject, value);
+        setParam(name, VarType.ShaderStorageBufferObject, value);
     }
 
     /**
@@ -788,7 +798,7 @@ public void selectTechnique(String name, final RenderManager renderManager) {
         sortingId = -1;
     }
 
-    private int applyOverrides(Renderer renderer, Shader shader, SafeArrayList<MatParamOverride> overrides, int unit) {
+    private void applyOverrides(Renderer renderer, Shader shader, SafeArrayList<MatParamOverride> overrides, BindUnits bindUnits) {
         for (MatParamOverride override : overrides.getArray()) {
             VarType type = override.getVarType();
 
@@ -801,71 +811,85 @@ private int applyOverrides(Renderer renderer, Shader shader, SafeArrayList<MatPa
             Uniform uniform = shader.getUniform(override.getPrefixedName());
 
             if (override.getValue() != null) {
-                if (type.isTextureType()) {
-                    renderer.setTexture(unit, (Texture) override.getValue());
-                    uniform.setValue(VarType.Int, unit);
-                    unit++;
-                } else {
-                    uniform.setValue(type, override.getValue());
-                }
+                updateShaderMaterialParameter(renderer,type,shader,override,bindUnits,true);
             } else {
                 uniform.clearValue();
             }
         }
-        return unit;
     }
 
-    private int updateShaderMaterialParameters(Renderer renderer, Shader shader,
+
+
+    private void updateShaderMaterialParameter(Renderer renderer,VarType type,Shader shader,MatParam param,BindUnits unit,boolean override){
+        if ( type == VarType.UniformBufferObject||type==VarType.ShaderStorageBufferObject) {
+
+            ShaderBufferBlock bufferBlock = shader.getBufferBlock(param.getPrefixedName());
+            BufferObject bufferObject=(BufferObject) param.getValue();
+
+            ShaderBufferBlock.BufferType btype;
+            if(type==VarType.ShaderStorageBufferObject){
+                btype=ShaderBufferBlock.BufferType.ShaderStorageBufferObject;
+                bufferBlock.setBufferObject(btype,bufferObject);
+                renderer.setShaderStorageBufferObject(unit.bufferUnit++,bufferObject);
+            }else{
+                btype=ShaderBufferBlock.BufferType.UniformBufferObject;
+                bufferBlock.setBufferObject(btype,bufferObject);
+                renderer.setUniformBufferObject(unit.bufferUnit++,bufferObject);
+            }
+
+
+        } else {
+            Uniform uniform = shader.getUniform(param.getPrefixedName());
+            if (!override&&uniform.isSetByCurrentMaterial())  return;
+
+            if (type.isTextureType()) {
+                renderer.setTexture(unit.textureUnit, (Texture) param.getValue());
+                uniform.setValue(VarType.Int, unit.textureUnit);
+                unit.textureUnit++;
+            } else {
+                uniform.setValue(type, param.getValue());
+            }
+        }
+    }
+
+
+    public static class BindUnits{
+        public int textureUnit=0;
+        public int bufferUnit=0;
+    }
+
+    private BindUnits bindUnits=new BindUnits();
+
+
+
+    private BindUnits updateShaderMaterialParameters(Renderer renderer, Shader shader,
                                                SafeArrayList<MatParamOverride> worldOverrides, SafeArrayList<MatParamOverride> forcedOverrides) {
+
 
-        int unit = 0;
+        bindUnits.textureUnit=0;
+        bindUnits.bufferUnit=0;
+
+
         if (worldOverrides != null) {
-            unit = applyOverrides(renderer, shader, worldOverrides, unit);
+            applyOverrides(renderer, shader, worldOverrides, bindUnits);
         }
         if (forcedOverrides != null) {
-            unit = applyOverrides(renderer, shader, forcedOverrides, unit);
+            applyOverrides(renderer, shader, forcedOverrides, bindUnits);
         }
 
         for (int i = 0; i < paramValues.size(); i++) {
 
             MatParam param = paramValues.getValue(i);
             VarType type = param.getVarType();
 
-            if (isBO(type)) {
-
-                final ShaderBufferBlock bufferBlock = shader.getBufferBlock(param.getPrefixedName());
-                bufferBlock.setBufferObject((BufferObject) param.getValue());
-
-            } else {
-
-                Uniform uniform = shader.getUniform(param.getPrefixedName());
-                if (uniform.isSetByCurrentMaterial()) {
-                    continue;
-                }
-
-                if (type.isTextureType()) {
-                    renderer.setTexture(unit, (Texture) param.getValue());
-                    uniform.setValue(VarType.Int, unit);
-                    unit++;
-                } else {
-                    uniform.setValue(type, param.getValue());
-                }
-            }
+            updateShaderMaterialParameter(renderer,type,shader,param,bindUnits,false);
         }
 
         //TODO HACKY HACK remove this when texture unit is handled by the uniform.
-        return unit;
+        return bindUnits;
     }
 
-    /**
-     * Returns true if the type is Buffer Object's type.
-     *
-     * @param type the material parameter type.
-     * @return true if the type is Buffer Object's type.
-     */
-    private boolean isBO(final VarType type) {
-        return type == VarType.BufferObject;
-    }
+
 
     private void updateRenderState(RenderManager renderManager, Renderer renderer, TechniqueDef techniqueDef) {
         if (renderManager.getForcedRenderState() != null) {
@@ -1019,13 +1043,13 @@ public void render(Geometry geometry, LightList lights, RenderManager renderMana
         renderManager.updateUniformBindings(shader);
 
         // Set material parameters
-        int unit = updateShaderMaterialParameters(renderer, shader, overrides, renderManager.getForcedMatParams());
+        BindUnits units= updateShaderMaterialParameters(renderer, shader, overrides, renderManager.getForcedMatParams());
 
         // Clear any uniforms not changed by material.
         resetUniformsNotSetByCurrent(shader);
 
         // Delegate rendering to the technique
-        technique.render(renderManager, shader, geometry, lights, unit);
+        technique.render(renderManager, shader, geometry, lights, units);
     }
 
     /**

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

@@ -33,6 +33,7 @@
 
 import com.jme3.asset.AssetManager;
 import com.jme3.light.LightList;
+import com.jme3.material.Material.BindUnits;
 import com.jme3.material.TechniqueDef.LightMode;
 import com.jme3.material.logic.TechniqueDefLogic;
 import com.jme3.renderer.Caps;
@@ -161,9 +162,9 @@ Shader makeCurrent(RenderManager renderManager, SafeArrayList<MatParamOverride>
      * @param geometry The geometry to render
      * @param lights Lights which influence the geometry.
      */
-    void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, int lastTexUnit) {
+    void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, BindUnits lastBindUnits) {
         TechniqueDefLogic logic = def.getLogic();
-        logic.render(renderManager, shader, geometry, lights, lastTexUnit);
+        logic.render(renderManager, shader, geometry, lights, lastBindUnits);
     }
 
     /**

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

@@ -34,6 +34,7 @@
 import com.jme3.asset.AssetManager;
 import com.jme3.light.*;
 import com.jme3.material.TechniqueDef;
+import com.jme3.material.Material.BindUnits;
 import com.jme3.math.ColorRGBA;
 import com.jme3.renderer.Caps;
 import com.jme3.renderer.RenderManager;
@@ -89,7 +90,7 @@ protected static ColorRGBA getAmbientColor(LightList lightList, boolean removeLi
 
 
     @Override
-    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, int lastTexUnit) {
+    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, BindUnits lastBindUnits) {
         Renderer renderer = renderManager.getRenderer();
         renderer.setShader(shader);
         renderMeshFromGeometry(renderer, geometry);

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

@@ -38,6 +38,7 @@
 import com.jme3.light.SpotLight;
 import com.jme3.material.RenderState;
 import com.jme3.material.TechniqueDef;
+import com.jme3.material.Material.BindUnits;
 import com.jme3.math.ColorRGBA;
 import com.jme3.math.Quaternion;
 import com.jme3.math.Vector3f;
@@ -67,7 +68,7 @@ public MultiPassLightingLogic(TechniqueDef techniqueDef) {
     }
 
     @Override
-    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, int lastTexUnit) {
+    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, BindUnits lastBindUnits) {
         Renderer r = renderManager.getRenderer();
         Uniform lightDir = shader.getUniform("g_LightDirection");
         Uniform lightColor = shader.getUniform("g_LightColor");

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

@@ -34,6 +34,7 @@
 import com.jme3.asset.AssetManager;
 import com.jme3.light.*;
 import com.jme3.material.*;
+import com.jme3.material.Material.BindUnits;
 import com.jme3.material.RenderState.BlendMode;
 import com.jme3.math.*;
 import com.jme3.renderer.*;
@@ -245,17 +246,17 @@ private int setProbeData(RenderManager rm, int lastTexUnit, Uniform lightProbeDa
     }
 
     @Override
-    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, int lastTexUnit) {
+    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, BindUnits lastBindUnits) {
         int nbRenderedLights = 0;
         Renderer renderer = renderManager.getRenderer();
         int batchSize = renderManager.getSinglePassLightBatchSize();
         if (lights.size() == 0) {
-            updateLightListUniforms(shader, geometry, lights,batchSize, renderManager, 0, lastTexUnit);
+            updateLightListUniforms(shader, geometry, lights,batchSize, renderManager, 0, lastBindUnits.textureUnit);
             renderer.setShader(shader);
             renderMeshFromGeometry(renderer, geometry);
         } else {
             while (nbRenderedLights < lights.size()) {
-                nbRenderedLights = updateLightListUniforms(shader, geometry, lights, batchSize, renderManager, nbRenderedLights, lastTexUnit);
+                nbRenderedLights = updateLightListUniforms(shader, geometry, lights, batchSize, renderManager, nbRenderedLights, lastBindUnits.textureUnit);
                 renderer.setShader(shader);
                 renderMeshFromGeometry(renderer, geometry);
             }

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

@@ -40,6 +40,7 @@
 import com.jme3.material.RenderState;
 import com.jme3.material.RenderState.BlendMode;
 import com.jme3.material.TechniqueDef;
+import com.jme3.material.Material.BindUnits;
 import com.jme3.math.ColorRGBA;
 import com.jme3.math.Vector3f;
 import com.jme3.math.Vector4f;
@@ -198,7 +199,7 @@ protected int updateLightListUniforms(Shader shader, Geometry g, LightList light
     }
 
     @Override
-    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, int lastTexUnit) {
+    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, BindUnits lastBindUnits) {
         int nbRenderedLights = 0;
         Renderer renderer = renderManager.getRenderer();
         int batchSize = renderManager.getSinglePassLightBatchSize();

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

@@ -38,6 +38,7 @@
 import com.jme3.light.PointLight;
 import com.jme3.light.SpotLight;
 import com.jme3.material.TechniqueDef;
+import com.jme3.material.Material.BindUnits;
 import com.jme3.math.ColorRGBA;
 import com.jme3.math.Matrix4f;
 import com.jme3.math.Vector3f;
@@ -171,7 +172,7 @@ private void updateLightListUniforms(Matrix4f viewMatrix, Shader shader, LightLi
     }
 
     @Override
-    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, int lastTexUnit) {
+    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, BindUnits lastBindUnits) {
         Renderer renderer = renderManager.getRenderer();
         Matrix4f viewMatrix = renderManager.getCurrentCamera().getViewMatrix();
         updateLightListUniforms(viewMatrix, shader, lights);

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

@@ -33,6 +33,7 @@
 
 import com.jme3.asset.AssetManager;
 import com.jme3.light.LightList;
+import com.jme3.material.Material.BindUnits;
 import com.jme3.renderer.Caps;
 import com.jme3.renderer.RenderManager;
 import com.jme3.scene.Geometry;
@@ -91,5 +92,5 @@ public Shader makeCurrent(AssetManager assetManager, RenderManager renderManager
      * @param geometry The geometry to render
      * @param lights Lights which influence the geometry.
      */
-    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, int lastTexUnit);
+    public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights, BindUnits lastBindUnits);
 }

jme3-core/src/main/java/com/jme3/math/FastMath.java

@@ -1005,4 +1005,11 @@ public static float unInterpolateLinear(float value, float min, float max) {
         return (value - min) / (max - min);
     }
 
+    /**
+     * Round n to a multiple of p
+     */
+    public static int toMultipleOf(int n, int p) {
+        return ((n - 1) | (p - 1)) + 1;
+    }
+
 }

jme3-core/src/main/java/com/jme3/renderer/RenderContext.java

@@ -31,10 +31,13 @@
  */
 package com.jme3.renderer;
 
+import java.lang.ref.WeakReference;
+
 import com.jme3.material.RenderState;
 import com.jme3.math.ColorRGBA;
 import com.jme3.scene.Mesh;
 import com.jme3.scene.VertexBuffer;
+import com.jme3.shader.BufferObject;
 import com.jme3.shader.Shader;
 import com.jme3.texture.FrameBuffer;
 import com.jme3.texture.Image;
@@ -221,6 +224,12 @@ public class RenderContext {
      */
     public final Image[] boundTextures = new Image[16];
 
+
+
+    public final WeakReference<BufferObject>[] boundBO = new WeakReference[8];
+
+
+
     /**
      * IDList for texture units
      *

jme3-core/src/main/java/com/jme3/renderer/Renderer.java

@@ -273,8 +273,15 @@ public interface Renderer {
      *
      * @param bo the buffer object to upload.
      */
-    public void updateBufferData(BufferObject bo);
-
+    public void updateShaderStorageBufferObjectData( BufferObject bo) ;
+
+    /**
+     * Uploads data of the buffer object on the GPU.
+     *
+     * @param bo the buffer object to upload.
+     */
+    public void updateUniformBufferObjectData( BufferObject bo) ;
+
     /**
      * Deletes a vertex buffer from the GPU.
      * @param vb The vertex buffer to delete
@@ -457,4 +464,7 @@ public interface Renderer {
      */
     public int getDefaultAnisotropicFilter();
 
+    public void setShaderStorageBufferObject(int bindingPoint, BufferObject bufferObject) ;
+    public void setUniformBufferObject(int bindingPoint, BufferObject bufferObject) ;
+
 }