singlepass sph baker and fast path

Author: riccardobl

jme3-core/src/main/java/com/jme3/environment/EnvironmentProbeControl.java

@@ -36,7 +36,6 @@
 import java.util.function.Predicate;
 import com.jme3.asset.AssetManager;
 import com.jme3.environment.baker.IBLGLEnvBakerLight;
-import com.jme3.environment.baker.IBLHybridEnvBakerLight;
 import com.jme3.export.InputCapsule;
 import com.jme3.export.JmeExporter;
 import com.jme3.export.JmeImporter;
@@ -49,7 +48,6 @@
 import com.jme3.scene.Node;
 import com.jme3.scene.Spatial;
 import com.jme3.scene.control.Control;
-import com.jme3.texture.Image.Format;
 
 /**
  * A control that automatically handles environment bake and rebake including
@@ -87,6 +85,8 @@ public class EnvironmentProbeControl extends LightProbe implements Control {
     private float frustumNear = 0.001f, frustumFar = 1000f;
     private String uuid = "none";
     private boolean enabled = true;
+    private IBLGLEnvBakerLight.SphericalHarmonicsMode sphericalHarmonicsMode =
+            IBLGLEnvBakerLight.SphericalHarmonicsMode.AUTO;
 
     private Predicate<Geometry> filter = (s) -> {
         return s.getUserData("tags.env") != null || s.getUserData("tags.env.env" + uuid) != null;
@@ -187,7 +187,18 @@ public static void untagGlobal(Spatial s) {
 
     @Override
     public Control cloneForSpatial(Spatial spatial) {
-        throw new UnsupportedOperationException();
+        EnvironmentProbeControl control = new EnvironmentProbeControl();
+        control.setAssetManager(assetManager);
+        control.setFrustumFar(frustumFar);
+        control.setFrustumNear(frustumNear);
+        control.setRequiredSavableResults(requiredSavableResults);
+        control.setEnabled(enabled);
+        control.setSphericalHarmonicsMode(sphericalHarmonicsMode);
+        control.envMapSize = envMapSize;
+        control.uuid = uuid;
+        control.filter = filter;
+        control.spatial = spatial;
+        return control;
     }
 
     /**
@@ -211,6 +222,38 @@ public boolean isRequiredSavableResults() {
         return requiredSavableResults;
     }
 
+    /**
+     * Sets how spherical harmonics coefficients are baked by this control.
+     *
+     * @param mode the spherical harmonics bake mode
+     */
+    public void setSphericalHarmonicsMode(IBLGLEnvBakerLight.SphericalHarmonicsMode mode) {
+        if (mode == null) {
+            throw new IllegalArgumentException("mode cannot be null");
+        }
+        sphericalHarmonicsMode = mode;
+    }
+
+    /**
+     * Returns the spherical harmonics bake mode used by this control.
+     *
+     * @return the spherical harmonics bake mode
+     */
+    public IBLGLEnvBakerLight.SphericalHarmonicsMode getSphericalHarmonicsMode() {
+        return sphericalHarmonicsMode;
+    }
+
+    /**
+     * Enables or disables the spherical harmonics fast path explicitly.
+     *
+     * @param enabled true to use the fast path, false to use the quality path
+     */
+    public void setSphericalHarmonicsFastPathEnabled(boolean enabled) {
+        setSphericalHarmonicsMode(enabled
+                ? IBLGLEnvBakerLight.SphericalHarmonicsMode.FAST
+                : IBLGLEnvBakerLight.SphericalHarmonicsMode.QUALITY);
+    }
+
     @Override
     public void setSpatial(Spatial spatial) {
         if (this.spatial != null && spatial != null && spatial != this.spatial) {
@@ -287,8 +330,9 @@ public void setAssetManager(AssetManager assetManager) {
     }
 
     void rebakeNow(RenderManager renderManager) {
-        IBLHybridEnvBakerLight baker = new IBLGLEnvBakerLight(renderManager, assetManager, null,
+        IBLGLEnvBakerLight baker = new IBLGLEnvBakerLight(renderManager, assetManager, null,
                 null, envMapSize, envMapSize);
+        baker.setSphericalHarmonicsMode(sphericalHarmonicsMode);
 
         baker.setTexturePulling(isRequiredSavableResults());
         baker.bakeEnvironment(spatial, getPosition(), frustumNear, frustumFar, filter);
@@ -331,6 +375,8 @@ public void write(JmeExporter ex) throws IOException {
         oc.write(frustumFar, "frustumFar", 1000f);
         oc.write(frustumNear, "frustumNear", 0.001f);
         oc.write(uuid, "envProbeControlUUID", "none");
+        oc.write(sphericalHarmonicsMode, "sphericalHarmonicsMode",
+                IBLGLEnvBakerLight.SphericalHarmonicsMode.AUTO);
     }
 
     @Override
@@ -346,6 +392,9 @@ public void read(JmeImporter im) throws IOException {
         frustumFar = ic.readFloat("frustumFar", 1000f);
         frustumNear = ic.readFloat("frustumNear", 0.001f);
         uuid = ic.readString("envProbeControlUUID", "none");
+        sphericalHarmonicsMode = ic.readEnum("sphericalHarmonicsMode",
+                IBLGLEnvBakerLight.SphericalHarmonicsMode.class,
+                IBLGLEnvBakerLight.SphericalHarmonicsMode.AUTO);
     }
 
 }

jme3-core/src/main/java/com/jme3/environment/baker/IBLGLEnvBakerLight.java

@@ -44,6 +44,8 @@
 import com.jme3.renderer.RenderManager;
 import com.jme3.scene.Geometry;
 import com.jme3.scene.shape.Box;
+import com.jme3.system.JmeSystem;
+import com.jme3.system.Platform;
 import com.jme3.texture.FrameBuffer;
 import com.jme3.texture.Image;
 import com.jme3.texture.Texture2D;
@@ -63,8 +65,31 @@
  */
 public class IBLGLEnvBakerLight extends IBLHybridEnvBakerLight {
     private static final int NUM_SH_COEFFICIENT = 9;
+    private static final int DEFAULT_FAST_SH_SAMPLE_COUNT = 8192;
     private static final Logger LOG = Logger.getLogger(IBLGLEnvBakerLight.class.getName());
 
+    /**
+     * Selects how spherical harmonics coefficients are baked on the GPU.
+     */
+    public enum SphericalHarmonicsMode {
+        /**
+         * Use full cubemap integration on desktop and the Hammersley fast path on
+         * Android and iOS.
+         */
+        AUTO,
+        /**
+         * Use Hammersley sampling.
+         */
+        FAST,
+        /**
+         * Integrate every cubemap texel in a single shader pass.
+         */
+        QUALITY
+    }
+
+    private SphericalHarmonicsMode sphericalHarmonicsMode = SphericalHarmonicsMode.AUTO;
+    private int sphericalHarmonicsFastPathSampleCount = DEFAULT_FAST_SH_SAMPLE_COUNT;
+
     /**
      * Create a new IBL env baker
      * 
@@ -91,6 +116,49 @@ public boolean isTexturePulling() {
         return this.texturePulling;
     }
 
+    /**
+     * Sets how spherical harmonics coefficients are baked.
+     *
+     * @param mode the spherical harmonics bake mode
+     */
+    public void setSphericalHarmonicsMode(SphericalHarmonicsMode mode) {
+        if (mode == null) {
+            throw new IllegalArgumentException("mode cannot be null");
+        }
+        this.sphericalHarmonicsMode = mode;
+    }
+
+    /**
+     * Returns the current spherical harmonics bake mode.
+     *
+     * @return the spherical harmonics bake mode
+     */
+    public SphericalHarmonicsMode getSphericalHarmonicsMode() {
+        return sphericalHarmonicsMode;
+    }
+
+    /**
+     * Sets the sample count used by the Hammersley spherical harmonics fast path.
+     *
+     * @param sampleCount the number of samples, must be positive
+     */
+    public void setSphericalHarmonicsFastPathSampleCount(int sampleCount) {
+        if (sampleCount <= 0) {
+            throw new IllegalArgumentException("sampleCount must be greater than zero");
+        }
+        this.sphericalHarmonicsFastPathSampleCount = sampleCount;
+    }
+
+    /**
+     * Returns the sample count used by the Hammersley spherical harmonics fast path.
+     *
+     * @return the Hammersley sample count
+     */
+    public int getSphericalHarmonicsFastPathSampleCount() {
+        return sphericalHarmonicsFastPathSampleCount;
+    }
+
+
     @Override
     public void bakeSphericalHarmonicsCoefficients() {
         Box boxm = new Box(1, 1, 1);
@@ -99,8 +167,25 @@ public void bakeSphericalHarmonicsCoefficients() {
         Material mat = new Material(assetManager, "Common/IBLSphH/IBLSphH.j3md");
         mat.setTexture("Texture", envMap);
         mat.setVector2("Resolution", new Vector2f(envMap.getImage().getWidth(), envMap.getImage().getHeight()));
+        mat.setInt("SampleCount", sphericalHarmonicsFastPathSampleCount);
         screen.setMaterial(mat);
 
+        switch (sphericalHarmonicsMode) {
+            case FAST: {
+                mat.setBoolean("UseFastSphericalHarmonics", true);
+                break;
+            }
+            case QUALITY: {
+                mat.setBoolean("UseFastSphericalHarmonics", false);
+                break;
+            }
+            case AUTO: {
+                Platform.Os os = JmeSystem.getPlatform().getOs();
+                mat.setBoolean("UseFastSphericalHarmonics",  os == Platform.Os.Android || os == Platform.Os.iOS);
+                break;
+            }
+        }
+
         float remapMaxValue = 0;
         Format format = Format.RGBA32F;
         if (!renderManager.getRenderer().getCaps().contains(Caps.FloatColorBufferRGBA)) {
@@ -117,38 +202,21 @@ public void bakeSphericalHarmonicsCoefficients() {
             mat.clearParam("RemapMaxValue");
         }
 
-        Texture2D shCoefTx[] = { new Texture2D(NUM_SH_COEFFICIENT, 1, 1, format), new Texture2D(NUM_SH_COEFFICIENT, 1, 1, format) };
-
-        FrameBuffer shbaker[] = { new FrameBuffer(NUM_SH_COEFFICIENT, 1, 1), new FrameBuffer(NUM_SH_COEFFICIENT, 1, 1) };
-        shbaker[0].setSrgb(false);
-        shbaker[0].addColorTarget(FrameBufferTarget.newTarget(shCoefTx[0]));
-
-        shbaker[1].setSrgb(false);
-        shbaker[1].addColorTarget(FrameBufferTarget.newTarget(shCoefTx[1]));
+        Texture2D shCoefTx = new Texture2D(NUM_SH_COEFFICIENT, 1, 1, format);
 
-        int renderOnT = -1;
+        FrameBuffer shbaker = new FrameBuffer(NUM_SH_COEFFICIENT, 1, 1);
+        shbaker.setSrgb(false);
+        shbaker.addColorTarget(FrameBufferTarget.newTarget(shCoefTx));
 
-        for (int faceId = 0; faceId < 6; faceId++) {
-            if (renderOnT != -1) {
-                int s = renderOnT;
-                renderOnT = renderOnT == 0 ? 1 : 0;
-                mat.setTexture("ShCoef", shCoefTx[s]);
-            } else {
-                renderOnT = 0;
-            }
-
-            mat.setInt("FaceId", faceId);
+        screen.updateLogicalState(0);
+        screen.updateGeometricState();
 
-            screen.updateLogicalState(0);
-            screen.updateGeometricState();
-
-            renderManager.setCamera(updateAndGetInternalCamera(0, shbaker[renderOnT].getWidth(), shbaker[renderOnT].getHeight(), Vector3f.ZERO, 1, 1000), false);
-            renderManager.getRenderer().setFrameBuffer(shbaker[renderOnT]);
-            renderManager.renderGeometry(screen);
-        }
+        renderManager.setCamera(updateAndGetInternalCamera(0, shbaker.getWidth(), shbaker.getHeight(), Vector3f.ZERO, 1, 1000), false);
+        renderManager.getRenderer().setFrameBuffer(shbaker);
+        renderManager.renderGeometry(screen);
 
-        ByteBuffer shCoefRaw = BufferUtils.createByteBuffer(NUM_SH_COEFFICIENT * 1 * (shbaker[renderOnT].getColorTarget().getFormat().getBitsPerPixel() / 8));
-        renderManager.getRenderer().readFrameBufferWithFormat(shbaker[renderOnT], shCoefRaw, shbaker[renderOnT].getColorTarget().getFormat());
+        ByteBuffer shCoefRaw = BufferUtils.createByteBuffer(NUM_SH_COEFFICIENT * 1 * (shbaker.getColorTarget().getFormat().getBitsPerPixel() / 8));
+        renderManager.getRenderer().readFrameBufferWithFormat(shbaker, shCoefRaw, shbaker.getColorTarget().getFormat());
         shCoefRaw.rewind();
 
         Image img = new Image(format, NUM_SH_COEFFICIENT, 1, shCoefRaw, ColorSpace.Linear);
@@ -176,6 +244,7 @@ else if (weightAccum != c.a) {
         }
         EnvMapUtils.prepareShCoefs(shCoef);
         img.dispose();
+        shbaker.dispose();
 
     }
 }

jme3-core/src/main/resources/Common/IBLSphH/IBLSphH.frag

@@ -15,11 +15,10 @@ in vec3 LocalPos;
 
 
 uniform samplerCube m_Texture;
-#ifdef SH_COEF
-    uniform sampler2D m_ShCoef;
+#ifdef FAST_SPHERICAL_HARMONICS
+    uniform int m_SampleCount;
 #endif
 uniform vec2 m_Resolution;
-uniform int m_FaceId;
 
 const float sqrtPi = sqrt(PI);
 const float sqrt3Pi = sqrt(3. / PI);
@@ -30,7 +29,6 @@ const float sqrt15Pi = sqrt(15. / PI);
     uniform float m_RemapMaxValue;
 #endif
 
-
 vec3 getVectorFromCubemapFaceTexCoord(float x, float y, float mapSize, int face) {
     float u;
     float v;
@@ -145,6 +143,37 @@ vec3 pixelFaceToV(int faceId, float pixelX, float pixelY, float cubeMapSize) {
     return normalize(direction);
 }
 
+#ifdef FAST_SPHERICAL_HARMONICS
+void sphHammersleyKernel(int coefficientIndex, out vec3 shCoef, out float weightAccum) {
+    vec3 texelVect = vec3(0.0);
+    float shDir = 0.0;
+    vec4 color = vec4(0.0);
+
+    shCoef = vec3(0.0);
+    weightAccum = 0.0;
+
+    for(int sampleIndex = 0; sampleIndex < m_SampleCount; sampleIndex++) {
+        vec4 xi = Hammersley(uint(sampleIndex), uint(m_SampleCount));
+        float z = 1.0 - 2.0 * xi.x;
+        float r = sqrt(max(0.0, 1.0 - z * z));
+        float phi = 2.0 * PI * xi.y;
+        texelVect = vec3(r * cos(phi), z, r * sin(phi));
+        evalShBasis(texelVect, coefficientIndex, shDir);
+        color = texture(m_Texture, texelVect);
+        shCoef.x = (shCoef.x + color.r * shDir);
+        shCoef.y = (shCoef.y + color.g * shDir);
+        shCoef.z = (shCoef.z + color.b * shDir);
+        weightAccum += 1.0;
+    }
+
+    #ifdef REMAP_MAX_VALUE
+        float sampleWeight = 4.0 * PI / float(m_SampleCount);
+        shCoef.xyz = shCoef.xyz * sampleWeight;
+        weightAccum = weightAccum * sampleWeight;
+    #endif
+}
+#endif
+
 void sphKernel() {
     int width = int(m_Resolution.x);
     int height = int(m_Resolution.y);
@@ -155,28 +184,26 @@ void sphKernel() {
 
     int i=int(gl_FragCoord.x);
 
-    #ifdef SH_COEF
-        vec4 r=texelFetch(m_ShCoef, ivec2(i, 0), 0);
-        vec3 shCoef=r.rgb;
-        float weightAccum = r.a;
-    #else
-        vec3 shCoef=vec3(0.0);
-        float weightAccum = 0.0;
-    #endif
+    vec3 shCoef=vec3(0.0);
+    float weightAccum = 0.0;
 
-    for(int y = 0; y < height; y++) {
-        for(int x = 0; x < width; x++) {
-            weight = getSolidAngleAndVector(float(x), float(y), float(width), m_FaceId, texelVect);
-            evalShBasis(texelVect, i, shDir);
-            color = texture(m_Texture, texelVect);
-            shCoef.x = (shCoef.x + color.r * shDir * weight);
-            shCoef.y = (shCoef.y + color.g * shDir * weight);
-            shCoef.z = (shCoef.z + color.b * shDir * weight);
-            weightAccum += weight;
+    #ifdef FAST_SPHERICAL_HARMONICS
+        sphHammersleyKernel(i, shCoef, weightAccum);
+    #else
+        for(int faceId = 0; faceId < 6; faceId++) {
+            for(int y = 0; y < height; y++) {
+                for(int x = 0; x < width; x++) {
+                    weight = getSolidAngleAndVector(float(x), float(y), float(width), faceId, texelVect);
+                    evalShBasis(texelVect, i, shDir);
+                    color = texture(m_Texture, texelVect);
+                    shCoef.x = (shCoef.x + color.r * shDir * weight);
+                    shCoef.y = (shCoef.y + color.g * shDir * weight);
+                    shCoef.z = (shCoef.z + color.b * shDir * weight);
+                    weightAccum += weight;
+                }
+            }
         }
-    }
-
-
+    #endif
 
     #ifdef REMAP_MAX_VALUE
         shCoef.xyz=shCoef.xyz*m_RemapMaxValue;