diff --git a/engine/src/core/com/jme3/post/Filter.java b/engine/src/core/com/jme3/post/Filter.java
index 93e65b23c..0c00c8f70 100644
--- a/engine/src/core/com/jme3/post/Filter.java
+++ b/engine/src/core/com/jme3/post/Filter.java
@@ -51,10 +51,16 @@ import java.util.Iterator;
import java.util.List;
/**
- * Filter abstract class
- * Any Filter must extends this class
- * Holds a frameBuffer and a texture
- * The getMaterial must return a Material that use a GLSL shader immplementing the desired effect
+ * Filters are 2D effects applied to the rendered scene.
+ * The filter is fed with the rendered scene image rendered in an offscreen frame buffer.
+ * This texture is applied on a fullscreen quad, with a special material.
+ * This material uses a shader that aplly the desired effect to the scene texture.
+ *
+ * This class is abstract, any Filter must extend it.
+ * Any filter holds a frameBuffer and a texture
+ * The getMaterial must return a Material that use a GLSL shader immplementing the desired effect
+ *
+ * @author Rémy Bouquet aka Nehon
*/
public abstract class Filter implements Savable {
@@ -69,6 +75,11 @@ public abstract class Filter implements Savable {
this.name = name;
}
+ /**
+ * Inner class Pass
+ * Pass are like filters in filters.
+ * Some filters will need multiple passes before the final render
+ */
public class Pass {
protected FrameBuffer renderFrameBuffer;
@@ -76,28 +87,52 @@ public abstract class Filter implements Savable {
protected Texture2D depthTexture;
protected Material passMaterial;
+ /**
+ * init the pass called internally
+ * @param renderer
+ * @param width
+ * @param height
+ * @param textureFormat
+ * @param depthBufferFormat
+ * @param numSamples
+ */
public void init(Renderer renderer, int width, int height, Format textureFormat, Format depthBufferFormat, int numSamples) {
Collection caps = renderer.getCaps();
if (numSamples > 1 && caps.contains(Caps.FrameBufferMultisample) && caps.contains(Caps.OpenGL31)) {
renderFrameBuffer = new FrameBuffer(width, height, numSamples);
- renderedTexture = new Texture2D(width, height, numSamples, textureFormat);
- // depthTexture = new Texture2D(width, height, numSamples, depthBufferFormat);
+ renderedTexture = new Texture2D(width, height, numSamples, textureFormat);
} else {
renderFrameBuffer = new FrameBuffer(width, height, 1);
renderedTexture = new Texture2D(width, height, textureFormat);
- // depthTexture = new Texture2D(width, height, depthBufferFormat);
}
renderFrameBuffer.setColorTexture(renderedTexture);
renderFrameBuffer.setDepthBuffer(depthBufferFormat);
- // renderFrameBuffer.setDepthTexture(depthTexture);
}
+ /**
+ * init the pass called internally
+ * @param renderer
+ * @param width
+ * @param height
+ * @param textureFormat
+ * @param depthBufferFormat
+ */
public void init(Renderer renderer, int width, int height, Format textureFormat, Format depthBufferFormat) {
init(renderer, width, height, textureFormat, depthBufferFormat, 1);
}
+ /**
+ * init the pass called internally
+ * @param renderer
+ * @param width
+ * @param height
+ * @param textureFormat
+ * @param depthBufferFormat
+ * @param numSample
+ * @param material
+ */
public void init(Renderer renderer, int width, int height, Format textureFormat, Format depthBufferFormat, int numSample, Material material) {
init(renderer, width, height, textureFormat, depthBufferFormat, numSample);
passMaterial = material;
@@ -146,26 +181,51 @@ public abstract class Filter implements Savable {
}
}
+ /**
+ * returns the default pass texture format
+ * @return
+ */
protected Format getDefaultPassTextureFormat() {
return Format.RGBA8;
}
+ /**
+ * returns the default pass depth format
+ * @return
+ */
protected Format getDefaultPassDepthFormat() {
return Format.Depth;
}
- public Filter() {
+ /**
+ * contruct a Filter
+ */
+ protected Filter() {
this("filter");
}
- public void init(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
+ /**
+ *
+ * initialize this filter
+ * use InitFilter for overriding filter initialization
+ * @param manager the assetManager
+ * @param renderManager the renderManager
+ * @param vp the viewport
+ * @param w the width
+ * @param h the height
+ */
+ protected final void init(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
// cleanup(renderManager.getRenderer());
defaultPass = new Pass();
defaultPass.init(renderManager.getRenderer(), w, h, getDefaultPassTextureFormat(), getDefaultPassDepthFormat());
initFilter(manager, renderManager, vp, w, h);
}
- public void cleanup(Renderer r) {
+ /**
+ * cleanup this filter
+ * @param r
+ */
+ protected final void cleanup(Renderer r) {
processor = null;
if (defaultPass != null) {
defaultPass.cleanup(r);
@@ -180,36 +240,49 @@ public abstract class Filter implements Savable {
}
/**
- * This method is called once xhen the filter is added to the FilterPostProcessor
- * It should contain Maerial initializations and extra passes initialization
- * @param manager
+ * Initialization of sub classes filters
+ * This method is called once when the filter is added to the FilterPostProcessor
+ * It should contain Material initializations and extra passes initialization
+ * @param manager the assetManager
+ * @param renderManager the renderManager
+ * @param vp the viewPort where this filter is rendered
+ * @param w the width of the filter
+ * @param h the height of the filter
+ */
+ protected abstract void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h);
+
+ /**
+ * override this method if you have some cleanup to do
+ * @param r the renderer
*/
- public abstract void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h);
+ protected void cleanUpFilter(Renderer r) {
+ }
- public abstract void cleanUpFilter(Renderer r);
+ ;
/**
- * Returns the material used for this filter.
+ * Must return the material used for this filter.
* this method is called every frame.
*
* @return the material used for this filter.
*/
- public abstract Material getMaterial();
+ protected abstract Material getMaterial();
/**
* Override this method if you want to make a pre pass, before the actual rendering of the frame
* @param renderManager
* @param viewPort
*/
- public void postQueue(RenderManager renderManager, ViewPort viewPort) {
+ protected void postQueue(RenderManager renderManager, ViewPort viewPort) {
}
/**
- * Use this method if you want to modify parameters according to tpf before the rendering of the frame.
+ * Override this method if you want to modify parameters according to tpf before the rendering of the frame.
* This is usefull for animated filters
+ * Also it can be the place to render pre passes
* @param tpf the time used to render the previous frame
*/
- public void preFrame(float tpf) {
+ protected void preFrame(float tpf) {
}
/**
@@ -217,7 +290,7 @@ public abstract class Filter implements Savable {
* @param renderManager
* @param viewPort
*/
- public void postFrame(RenderManager renderManager, ViewPort viewPort, FrameBuffer prevFilterBuffer, FrameBuffer sceneBuffer) {
+ protected void postFrame(RenderManager renderManager, ViewPort viewPort, FrameBuffer prevFilterBuffer, FrameBuffer sceneBuffer) {
}
/**
@@ -243,56 +316,84 @@ public abstract class Filter implements Savable {
enabled = ic.readBoolean("enabled", true);
}
+ /**
+ * returns the name of the filter
+ * @return
+ */
public String getName() {
return name;
}
+ /**
+ * Sets the name of the filter
+ * @param name
+ */
public void setName(String name) {
this.name = name;
}
- public FrameBuffer getRenderFrameBuffer() {
+ /**
+ * returns the default pass frame buffer
+ * @return
+ */
+ protected FrameBuffer getRenderFrameBuffer() {
return defaultPass.renderFrameBuffer;
}
- public void setRenderFrameBuffer(FrameBuffer renderFrameBuffer) {
+ /**
+ * sets the default pas frame buffer
+ * @param renderFrameBuffer
+ */
+ protected void setRenderFrameBuffer(FrameBuffer renderFrameBuffer) {
this.defaultPass.renderFrameBuffer = renderFrameBuffer;
}
- public Texture2D getRenderedTexture() {
+ /**
+ * returns the rendered texture of this filter
+ * @return
+ */
+ protected Texture2D getRenderedTexture() {
return defaultPass.renderedTexture;
}
- public void setRenderedTexture(Texture2D renderedTexture) {
+ /**
+ * sets the rendered texture of this filter
+ * @param renderedTexture
+ */
+ protected void setRenderedTexture(Texture2D renderedTexture) {
this.defaultPass.renderedTexture = renderedTexture;
}
/**
- * Override this method and return true if your Filter need the depth texture
+ * Override this method and return true if your Filter needs the depth texture
*
* @return true if your Filter need the depth texture
*/
- public boolean isRequiresDepthTexture() {
+ protected boolean isRequiresDepthTexture() {
return false;
}
-
- /**
+
+ /**
* Override this method and return false if your Filter does not need the scene texture
*
* @return false if your Filter does not need the scene texture
*/
- public boolean isRequiresSceneTexture() {
+ protected boolean isRequiresSceneTexture() {
return true;
}
- public List getPostRenderPasses() {
+ /**
+ * returns the list of the postRender passes
+ * @return
+ */
+ protected List getPostRenderPasses() {
return postRenderPasses;
}
- public void setPostRenderPasses(List postRenderPasses) {
- this.postRenderPasses = postRenderPasses;
- }
-
+ /**
+ * Enable or disable this filter
+ * @param enabled true to enable
+ */
public void setEnabled(boolean enabled) {
if (processor != null) {
processor.setFilterState(this, enabled);
@@ -301,10 +402,18 @@ public abstract class Filter implements Savable {
}
}
+ /**
+ * returns ttrue if the filter is enabled
+ * @return enabled
+ */
public boolean isEnabled() {
return enabled;
}
+ /**
+ * sets a reference to the FilterPostProcessor ti which this filter is attached
+ * @param proc
+ */
protected void setProcessor(FilterPostProcessor proc) {
processor = proc;
}
diff --git a/engine/src/core/com/jme3/post/FilterPostProcessor.java b/engine/src/core/com/jme3/post/FilterPostProcessor.java
index cb2b50fa6..b35c00a6f 100644
--- a/engine/src/core/com/jme3/post/FilterPostProcessor.java
+++ b/engine/src/core/com/jme3/post/FilterPostProcessor.java
@@ -55,6 +55,11 @@ import java.util.Collection;
import java.util.Iterator;
import java.util.List;
+/**
+ * A FilterPostProcessor is a processor that can apply several {@link Filter}s to a rendered scene
+ * It manages a list of filters that will be applied in the order in which they've been added to the list
+ * @author Rémy Bouquet aka Nehon
+ */
public class FilterPostProcessor implements SceneProcessor, Savable {
private RenderManager renderManager;
@@ -81,25 +86,26 @@ public class FilterPostProcessor implements SceneProcessor, Savable {
private int originalHeight;
private int lastFilterIndex = -1;
private boolean cameraInit = false;
-// private boolean handleTranslucentBucket = false;
-// private FrameBuffer transFrameBuffer;
-// private Material transMaterial;
-// private boolean isTransparencyRendered=false;
/**
- * Create a FilterProcessor constructor
- * @param assetManager the Asset Manager
+ * Create a FilterProcessor
+ * @param assetManager the assetManager
*/
public FilterPostProcessor(AssetManager assetManager) {
this.assetManager = assetManager;
}
/**
- * Don't use this constructor use FilterPostProcessor(AssetManager assetManager)
+ * Don't use this constructor use {@link FilterPostProcessor(AssetManager assetManager)}
+ * This constructor is used for serialization only
*/
public FilterPostProcessor() {
}
+ /**
+ * Adds a filter to the filters list
+ * @param filter the filter to add
+ */
public void addFilter(Filter filter) {
filters.add(filter);
filter.setProcessor(this);
@@ -112,6 +118,10 @@ public class FilterPostProcessor implements SceneProcessor, Savable {
}
+ /**
+ * removes this filters from the filters list
+ * @param filter
+ */
public void removeFilter(Filter filter) {
for (Iterator it = filters.iterator(); it.hasNext();) {
if (it.next() == filter) {
@@ -140,6 +150,11 @@ public class FilterPostProcessor implements SceneProcessor, Savable {
reshape(vp, cam.getWidth(), cam.getHeight());
}
+ /**
+ * init the given filter
+ * @param filter
+ * @param vp
+ */
private void initFilter(Filter filter, ViewPort vp) {
filter.init(assetManager, renderManager, vp, width, height);
if (filter.isRequiresDepthTexture()) {
@@ -152,6 +167,12 @@ public class FilterPostProcessor implements SceneProcessor, Savable {
}
}
+ /**
+ * renders a filter on a fullscreen quad
+ * @param r
+ * @param buff
+ * @param mat
+ */
private void renderProcessing(Renderer r, FrameBuffer buff, Material mat) {
if (buff == outputBuffer) {
fsQuad.setWidth(width);
@@ -199,7 +220,12 @@ public class FilterPostProcessor implements SceneProcessor, Savable {
}
Picture pic = new Picture("debug");
- public void renderFilterChain(Renderer r, FrameBuffer sceneFb) {
+ /**
+ * iterate through the filter list and renders filters
+ * @param r
+ * @param sceneFb
+ */
+ private void renderFilterChain(Renderer r, FrameBuffer sceneFb) {
Texture2D tex = filterTexture;
FrameBuffer buff = sceneFb;
boolean msDepth = depthTexture != null && depthTexture.getImage().getMultiSamples() > 1;
@@ -268,7 +294,7 @@ public class FilterPostProcessor implements SceneProcessor, Savable {
}
renderFilterChain(renderer, sceneBuffer);
renderManager.setCamera(viewPort.getCamera(), false);
-
+
renderer.setFrameBuffer(outputBuffer);
}
@@ -305,6 +331,11 @@ public class FilterPostProcessor implements SceneProcessor, Savable {
}
+ /**
+ * sets the filter to enabled or disabled
+ * @param filter
+ * @param enabled
+ */
protected void setFilterState(Filter filter, boolean enabled) {
if (filters.contains(filter)) {
filter.enabled = enabled;
@@ -312,6 +343,9 @@ public class FilterPostProcessor implements SceneProcessor, Savable {
}
}
+ /**
+ * compute the index of the last filter to render
+ */
private void updateLastFilterIndex() {
lastFilterIndex = -1;
for (int i = filters.size() - 1; i >= 0 && lastFilterIndex == -1; i--) {
@@ -423,32 +457,32 @@ public class FilterPostProcessor implements SceneProcessor, Savable {
this.assetManager = assetManager;
}
- /**
- * Writes the processor
- * @param ex
- * @throws IOException
- */
public void write(JmeExporter ex) throws IOException {
OutputCapsule oc = ex.getCapsule(this);
oc.write(numSamples, "numSamples", 0);
oc.writeSavableArrayList((ArrayList) filters, "filters", null);
}
- /**
- * Reads the processor
- * @param im
- * @throws IOException
- */
public void read(JmeImporter im) throws IOException {
InputCapsule ic = im.getCapsule(this);
numSamples = ic.readInt("numSamples", 0);
filters = ic.readSavableArrayList("filters", null);
}
+ /**
+ * For internal use only
+ * returns the depth texture of the scene
+ * @return
+ */
public Texture2D getDepthTexture() {
return depthTexture;
}
+ /**
+ * For internal use only
+ * returns the rendered texture of the scene
+ * @return
+ */
public Texture2D getFilterTexture() {
return filterTexture;
}
diff --git a/engine/src/core/com/jme3/post/SceneProcessor.java b/engine/src/core/com/jme3/post/SceneProcessor.java
index 7b986c7ca..80301cb79 100644
--- a/engine/src/core/com/jme3/post/SceneProcessor.java
+++ b/engine/src/core/com/jme3/post/SceneProcessor.java
@@ -37,9 +37,15 @@ import com.jme3.renderer.ViewPort;
import com.jme3.renderer.queue.RenderQueue;
import com.jme3.texture.FrameBuffer;
+/**
+ * Scene processors are used to compute/render things before and after the classic render of the scene.
+ * They have to be added to a viewport and are rendered in the order they've been added
+ * @author Kirill Vainer aka Shadowislord aka Momoko_Fan
+ */
public interface SceneProcessor {
/**
+ * For internal use only
* Called in the render thread to initialize the scene processor.
*
* @param rm The render manager to which the SP was added to
@@ -48,6 +54,7 @@ public interface SceneProcessor {
public void initialize(RenderManager rm, ViewPort vp);
/**
+ * For internal use only
* Called when the resolution of the viewport has been changed.
* @param vp
*/
@@ -60,6 +67,7 @@ public interface SceneProcessor {
public boolean isInitialized();
/**
+ * For internal use only
* Called before a frame
*
* @param tpf Time per frame
@@ -67,6 +75,7 @@ public interface SceneProcessor {
public void preFrame(float tpf);
/**
+ * For internal use only
* Called after the scene graph has been queued, but before it is flushed.
*
* @param rq The render queue
@@ -74,6 +83,7 @@ public interface SceneProcessor {
public void postQueue(RenderQueue rq);
/**
+ * For internal use only
* Called after a frame has been rendered and the queue flushed.
*
* @param out The FB to which the scene was rendered.
@@ -81,6 +91,7 @@ public interface SceneProcessor {
public void postFrame(FrameBuffer out);
/**
+ * For internal use only
* Called when the SP is removed from the RM.
*/
public void cleanup();
diff --git a/engine/src/desktop-fx/com/jme3/post/filters/BloomFilter.java b/engine/src/desktop-fx/com/jme3/post/filters/BloomFilter.java
index b1e4875b6..8f549acb7 100644
--- a/engine/src/desktop-fx/com/jme3/post/filters/BloomFilter.java
+++ b/engine/src/desktop-fx/com/jme3/post/filters/BloomFilter.java
@@ -40,36 +40,37 @@ import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.post.Filter;
import com.jme3.renderer.RenderManager;
-import com.jme3.renderer.Renderer;
import com.jme3.renderer.ViewPort;
import com.jme3.texture.Image.Format;
import java.io.IOException;
import java.util.ArrayList;
/**
- * BloomFilter
is used to make objects in the scene have a
- * "soap opera" glow effect.
- *
- * @author Nehon
+ * BloomFilter is used to make objects in the scene have a glow effect.
+ * There are 2 mode : Scene and Objects.
+ * Scene mode extracts the bright parts of the scene to make them glow
+ * Object mode make objects glow according to their material's glowMap or their GlowColor
+ * see {@link http://jmonkeyengine.org/wiki/doku.php/jme3:advanced:bloom_and_glow} for more details
+ *
+ * @author Rémy Bouquet aka Nehon
*/
public class BloomFilter extends Filter {
/**
- * GlowMode
specifies if bright objects or objects
- * with glow map will be bloomed.
+ * GlowMode specifies if the glow will be applied to the whole scene,or to objects that have aglow color or a glow map
*/
public enum GlowMode {
/**
- * Apply bloom filter to bright objects in the scene.
+ * Apply bloom filter to bright areas in the scene.
*/
Scene,
/**
- * Apply bloom only to objects that have a glow map.
+ * Apply bloom only to objects that have a glow map or a glow color.
*/
Objects,
/**
- * Apply bloom to both bright objects and objects with glow map.
+ * Apply bloom to both bright parts of the scene and objects with glow map.
*/
SceneAndObjects;
}
@@ -93,14 +94,14 @@ public class BloomFilter extends Filter {
private ColorRGBA backupColor;
/**
- * creates a Bloom filter
+ * Creates a Bloom filter
*/
public BloomFilter() {
super("BloomFilter");
}
/**
- * Crete the bloom filter with the specific glow mode
+ * Creates the bloom filter with the specific glow mode
* @param glowMode
*/
public BloomFilter(GlowMode glowMode) {
@@ -109,7 +110,7 @@ public class BloomFilter extends Filter {
}
@Override
- public void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
+ protected void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
screenWidth = (int) (w / downSamplingFactor);
screenHeight = (int) (h / downSamplingFactor);
// System.out.println(screenWidth + " " + screenHeight);
@@ -178,31 +179,15 @@ public class BloomFilter extends Filter {
material.setTexture("BloomTex", verticalalBlur.getRenderedTexture());
}
- @Override
- public void cleanUpFilter(Renderer r) {
-
- if (preGlowPass != null) {
- preGlowPass.cleanup(r);
- }
- if (extractPass != null) {
- extractPass.cleanup(r);
- }
- if (horizontalBlur != null) {
- horizontalBlur.cleanup(r);
- }
- if (verticalalBlur != null) {
- verticalalBlur.cleanup(r);
- }
- }
@Override
- public Material getMaterial() {
+ protected Material getMaterial() {
material.setFloat("BloomIntensity", bloomIntensity);
return material;
}
@Override
- public void postQueue(RenderManager renderManager, ViewPort viewPort) {
+ protected void postQueue(RenderManager renderManager, ViewPort viewPort) {
if (glowMode != GlowMode.Scene) {
backupColor = viewPort.getBackgroundColor();
viewPort.setBackgroundColor(ColorRGBA.Black);
@@ -216,30 +201,43 @@ public class BloomFilter extends Filter {
}
}
+ /**
+ * returns the bloom intensity
+ * @return
+ */
public float getBloomIntensity() {
return bloomIntensity;
}
/**
- * intensity of the bloom effect
+ * intensity of the bloom effect default is 2.0
* @param bloomIntensity
*/
public void setBloomIntensity(float bloomIntensity) {
this.bloomIntensity = bloomIntensity;
}
+ /**
+ * returns the blur scale
+ * @return
+ */
public float getBlurScale() {
return blurScale;
}
/**
- * The spread of the bloom
+ * sets The spread of the bloom default is 1.5f
* @param blurScale
*/
public void setBlurScale(float blurScale) {
this.blurScale = blurScale;
}
+ /**
+ * returns the exposure cutoff
+ * for more details see {@link setExposureCutOff(float exposureCutOff)}
+ * @return
+ */
public float getExposureCutOff() {
return exposureCutOff;
}
@@ -252,12 +250,18 @@ public class BloomFilter extends Filter {
this.exposureCutOff = exposureCutOff;
}
+ /**
+ * returns the exposure power
+ * form more details see {@link setExposurePower(float exposurePower)}
+ * @return
+ */
public float getExposurePower() {
return exposurePower;
}
/**
- * the power of the bloomed color
+ * defines how many time the bloom extracted color will be multiplied by itself. default id 5.0
+ * a high value will reduce rough edges in the bloom and somhow the range of the bloom area *
* @param exposurePower
*/
public void setExposurePower(float exposurePower) {
@@ -265,7 +269,8 @@ public class BloomFilter extends Filter {
}
/**
- * returns the downSampling factor
+ * returns the downSampling factor
+ * form more details see {@link setDownSamplingFactor(float downSamplingFactor)}
* @return
*/
public float getDownSamplingFactor() {
@@ -273,7 +278,7 @@ public class BloomFilter extends Filter {
}
/**
- * Sets the downSampling factor : the size of the computed texture will be divided by this factor.
+ * Sets the downSampling factor : the size of the computed texture will be divided by this factor. default is 1 for no downsampling
* A 2 value is a good way of widening the blur
* @param downSamplingFactor
*/
diff --git a/engine/src/desktop-fx/com/jme3/post/filters/CartoonEdgeFilter.java b/engine/src/desktop-fx/com/jme3/post/filters/CartoonEdgeFilter.java
index a6c347d42..3e9998ba7 100644
--- a/engine/src/desktop-fx/com/jme3/post/filters/CartoonEdgeFilter.java
+++ b/engine/src/desktop-fx/com/jme3/post/filters/CartoonEdgeFilter.java
@@ -55,19 +55,22 @@ public class CartoonEdgeFilter extends Filter {
private float depthThreshold = 0.1f;
private float normalSensitivity = 1.0f;
private float depthSensitivity = 10.0f;
- private ColorRGBA edgeColor=new ColorRGBA(0, 0, 0, 1);
+ private ColorRGBA edgeColor = new ColorRGBA(0, 0, 0, 1);
+ /**
+ * Creates a CartoonEdgeFilter
+ */
public CartoonEdgeFilter() {
super("CartoonEdgeFilter");
}
@Override
- public boolean isRequiresDepthTexture() {
+ protected boolean isRequiresDepthTexture() {
return true;
}
@Override
- public void postQueue(RenderManager renderManager, ViewPort viewPort) {
+ protected void postQueue(RenderManager renderManager, ViewPort viewPort) {
Renderer r = renderManager.getRenderer();
r.setFrameBuffer(normalPass.getRenderFrameBuffer());
renderManager.getRenderer().clearBuffers(true, true, true);
@@ -78,13 +81,13 @@ public class CartoonEdgeFilter extends Filter {
}
@Override
- public Material getMaterial() {
+ protected Material getMaterial() {
material.setTexture("NormalsTexture", normalPass.getRenderedTexture());
return material;
}
@Override
- public void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
+ protected void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
normalPass = new Pass();
normalPass.init(renderManager.getRenderer(), w, h, Format.RGBA8, Format.Depth);
material = new Material(manager, "Common/MatDefs/Post/CartoonEdge.j3md");
@@ -97,17 +100,20 @@ public class CartoonEdgeFilter extends Filter {
material.setColor("EdgeColor", edgeColor);
}
- @Override
- public void cleanUpFilter(Renderer r) {
- if (normalPass != null) {
- normalPass.cleanup(r);
- }
- }
-
+ /**
+ * Return the depth sensitivity
+ * for more details see {@link setDepthSensitivity(float depthSensitivity)}
+ * @return
+ */
public float getDepthSensitivity() {
return depthSensitivity;
}
+ /**
+ * sets the depth sensitivity
+ * defines how much depth will influence edges, default is 10
+ * @param depthSensitivity
+ */
public void setDepthSensitivity(float depthSensitivity) {
this.depthSensitivity = depthSensitivity;
if (material != null) {
@@ -115,10 +121,20 @@ public class CartoonEdgeFilter extends Filter {
}
}
+ /**
+ * returns the depth threshold
+ * for more details see {@link setDepthThreshold(float depthThreshold)}
+ * @return
+ */
public float getDepthThreshold() {
return depthThreshold;
}
+ /**
+ * sets the depth threshold
+ * Defines at what threshold of difference of depth an edge is outlined default is 0.1f
+ * @param depthThreshold
+ */
public void setDepthThreshold(float depthThreshold) {
this.depthThreshold = depthThreshold;
if (material != null) {
@@ -126,10 +142,20 @@ public class CartoonEdgeFilter extends Filter {
}
}
+ /**
+ * returns the edge intensity
+ * for more details see {@link setEdgeIntensity(float edgeIntensity) }
+ * @return
+ */
public float getEdgeIntensity() {
return edgeIntensity;
}
+ /**
+ * sets the edge intensity
+ * Defineshow visilble will be the outlined edges
+ * @param edgeIntensity
+ */
public void setEdgeIntensity(float edgeIntensity) {
this.edgeIntensity = edgeIntensity;
if (material != null) {
@@ -137,10 +163,18 @@ public class CartoonEdgeFilter extends Filter {
}
}
+ /**
+ * returns the width of the edges
+ * @return
+ */
public float getEdgeWidth() {
return edgeWidth;
}
+ /**
+ * sets the witdh of the edge in pixels default is 1
+ * @param edgeWidth
+ */
public void setEdgeWidth(float edgeWidth) {
this.edgeWidth = edgeWidth;
if (material != null) {
@@ -149,10 +183,19 @@ public class CartoonEdgeFilter extends Filter {
}
+ /**
+ * returns the normals sensitivity
+ * form more details see {@link setNormalSensitivity(float normalSensitivity)}
+ * @return
+ */
public float getNormalSensitivity() {
return normalSensitivity;
}
+ /**
+ * sets the normals sensitivity default is 1
+ * @param normalSensitivity
+ */
public void setNormalSensitivity(float normalSensitivity) {
this.normalSensitivity = normalSensitivity;
if (material != null) {
@@ -160,10 +203,20 @@ public class CartoonEdgeFilter extends Filter {
}
}
+ /**
+ * returns the normal threshold
+ * for more details see {@link setNormalThreshold(float normalThreshold)}
+ *
+ * @return
+ */
public float getNormalThreshold() {
return normalThreshold;
}
+ /**
+ * sets the normal threshold default is 0.5
+ * @param normalThreshold
+ */
public void setNormalThreshold(float normalThreshold) {
this.normalThreshold = normalThreshold;
if (material != null) {
@@ -185,10 +238,8 @@ public class CartoonEdgeFilter extends Filter {
*/
public void setEdgeColor(ColorRGBA edgeColor) {
this.edgeColor = edgeColor;
- if(material!=null){
+ if (material != null) {
material.setColor("EdgeColor", edgeColor);
}
}
-
-
}
diff --git a/engine/src/desktop-fx/com/jme3/post/filters/ColorOverlayFilter.java b/engine/src/desktop-fx/com/jme3/post/filters/ColorOverlayFilter.java
index 5a18346af..a7f30f884 100644
--- a/engine/src/desktop-fx/com/jme3/post/filters/ColorOverlayFilter.java
+++ b/engine/src/desktop-fx/com/jme3/post/filters/ColorOverlayFilter.java
@@ -40,44 +40,58 @@ import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.post.Filter;
import com.jme3.renderer.RenderManager;
-import com.jme3.renderer.Renderer;
import com.jme3.renderer.ViewPort;
import java.io.IOException;
/**
- *
- * @author nehon
+ * This filter simply multiply the whole scene by a color
+ * @author Rémy Bouquet aka Nehon
*/
public class ColorOverlayFilter extends Filter {
private ColorRGBA color = ColorRGBA.White;
+ /**
+ * creates a colorOverlayFilter with a white coor (transparent)
+ */
public ColorOverlayFilter() {
super("Color Overlay");
}
+ /**
+ * creates a colorOverlayFilter with the given color
+ * @param color
+ */
public ColorOverlayFilter(ColorRGBA color) {
this();
this.color = color;
}
@Override
- public Material getMaterial() {
+ protected Material getMaterial() {
material.setColor("Color", color);
return material;
}
+ /**
+ * returns the color
+ * @return color
+ */
public ColorRGBA getColor() {
return color;
}
+ /**
+ * sets the color
+ * @param color
+ */
public void setColor(ColorRGBA color) {
this.color = color;
}
@Override
- public void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
+ protected void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
material = new Material(manager, "Common/MatDefs/Post/Overlay.j3md");
}
@@ -94,8 +108,4 @@ public class ColorOverlayFilter extends Filter {
InputCapsule ic = im.getCapsule(this);
color = (ColorRGBA) ic.readSavable("color", ColorRGBA.White);
}
-
- @Override
- public void cleanUpFilter(Renderer r) {
- }
}
diff --git a/engine/src/desktop-fx/com/jme3/post/filters/CrossHatchFilter.java b/engine/src/desktop-fx/com/jme3/post/filters/CrossHatchFilter.java
index 388e52d1b..0eb204993 100644
--- a/engine/src/desktop-fx/com/jme3/post/filters/CrossHatchFilter.java
+++ b/engine/src/desktop-fx/com/jme3/post/filters/CrossHatchFilter.java
@@ -36,7 +36,6 @@ import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.post.Filter;
import com.jme3.renderer.RenderManager;
-import com.jme3.renderer.Renderer;
import com.jme3.renderer.ViewPort;
/*
@@ -64,10 +63,18 @@ public class CrossHatchFilter extends Filter {
private float lineThickness = 1.0f;
private float lineDistance = 4.0f;
+ /**
+ * Creates a crossHatch filter
+ */
public CrossHatchFilter() {
super("CrossHatchFilter");
}
+ /**
+ * Creates a crossHatch filter
+ * @param lineColor the colors of the lines
+ * @param paperColor the paper color
+ */
public CrossHatchFilter(ColorRGBA lineColor, ColorRGBA paperColor) {
this();
this.lineColor = lineColor;
@@ -75,12 +82,12 @@ public class CrossHatchFilter extends Filter {
}
@Override
- public boolean isRequiresDepthTexture() {
+ protected boolean isRequiresDepthTexture() {
return false;
}
@Override
- public void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
+ protected void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
material = new Material(manager, "Common/MatDefs/Post/CrossHatch.j3md");
material.setColor("LineColor", lineColor);
material.setColor("PaperColor", paperColor);
@@ -101,16 +108,13 @@ public class CrossHatchFilter extends Filter {
}
@Override
- public Material getMaterial() {
+ protected Material getMaterial() {
return material;
}
- @Override
- public void cleanUpFilter(Renderer r) {
- }
-
- /*
+ /**
* Sets color used to draw lines
+ * @param lineColor
*/
public void setLineColor(ColorRGBA lineColor) {
this.lineColor = lineColor;
@@ -119,8 +123,9 @@ public class CrossHatchFilter extends Filter {
}
}
- /*
+ /**
* Sets color used as background
+ * @param paperColor
*/
public void setPaperColor(ColorRGBA paperColor) {
this.paperColor = paperColor;
@@ -128,10 +133,11 @@ public class CrossHatchFilter extends Filter {
material.setColor("PaperColor", paperColor);
}
}
- /*
+
+ /**
* Sets color influence of original image on lines drawn
+ * @param colorInfluenceLine
*/
-
public void setColorInfluenceLine(float colorInfluenceLine) {
this.colorInfluenceLine = colorInfluenceLine;
if (material != null) {
@@ -139,8 +145,9 @@ public class CrossHatchFilter extends Filter {
}
}
- /*
+ /**
* Sets color influence of original image on non-line areas
+ * @param colorInfluencePaper
*/
public void setColorInfluencePaper(float colorInfluencePaper) {
this.colorInfluencePaper = colorInfluencePaper;
@@ -149,9 +156,10 @@ public class CrossHatchFilter extends Filter {
}
}
- /*
+ /**
* Sets line/paper color ratio for areas with values < luminance5,
* really dark areas get no lines but a filled blob instead
+ * @param fillValue
*/
public void setFillValue(float fillValue) {
this.fillValue = fillValue;
@@ -160,13 +168,14 @@ public class CrossHatchFilter extends Filter {
}
}
- /*
+ /**
+ *
* Sets minimum luminance levels for lines drawn
- * Luminance1: Top-left to down right 1
- * Luminance2: Top-right to bottom left 1
- * Luminance3: Top-left to down right 2
- * Luminance4: Top-right to bottom left 2
- * Luminance5: Blobs
+ * @param luminance1 Top-left to down right 1
+ * @param luminance2 Top-right to bottom left 1
+ * @param luminance3 Top-left to down right 2
+ * @param luminance4 Top-right to bottom left 2
+ * @param luminance5 Blobs
*/
public void setLuminanceLevels(float luminance1, float luminance2, float luminance3, float luminance4, float luminance5) {
this.luminance1 = luminance1;
@@ -184,8 +193,9 @@ public class CrossHatchFilter extends Filter {
}
}
- /*
+ /**
* Sets the thickness of lines drawn
+ * @param lineThickness
*/
public void setLineThickness(float lineThickness) {
this.lineThickness = lineThickness;
@@ -194,10 +204,11 @@ public class CrossHatchFilter extends Filter {
}
}
- /*
+ /**
* Sets minimum distance between lines drawn
* Primary lines are drawn at 2*lineDistance
* Secondary lines are drawn at lineDistance
+ * @param lineDistance
*/
public void setLineDistance(float lineDistance) {
this.lineDistance = lineDistance;
@@ -206,84 +217,86 @@ public class CrossHatchFilter extends Filter {
}
}
- /*
+ /**
* Returns line color
+ * @return
*/
public ColorRGBA getLineColor() {
return lineColor;
}
- /*
+ /**
* Returns paper background color
+ * @return
*/
public ColorRGBA getPaperColor() {
return paperColor;
}
- /*
+ /**
* Returns current influence of image colors on lines
*/
public float getColorInfluenceLine() {
return colorInfluenceLine;
}
- /*
+ /**
* Returns current influence of image colors on paper background
*/
public float getColorInfluencePaper() {
return colorInfluencePaper;
}
- /*
+ /**
* Returns line/paper color ratio for blobs
*/
public float getFillValue() {
return fillValue;
}
- /*
+ /**
* Returns the thickness of the lines drawn
*/
public float getLineThickness() {
return lineThickness;
}
- /*
+ /**
* Returns minimum distance between lines
*/
public float getLineDistance() {
return lineDistance;
}
- /*
+ /**
* Returns treshold for lines 1
*/
public float getLuminance1() {
return luminance1;
}
- /*
+ /**
* Returns treshold for lines 2
*/
public float getLuminance2() {
return luminance2;
}
- /*
+ /**
* Returns treshold for lines 3
*/
public float getLuminance3() {
return luminance3;
}
- /*
+ /**
* Returns treshold for lines 4
*/
public float getLuminance4() {
return luminance4;
}
- /*
+ /**
* Returns treshold for blobs
*/
public float getLuminance5() {
diff --git a/engine/src/desktop-fx/com/jme3/post/filters/DepthOfFieldFilter.java b/engine/src/desktop-fx/com/jme3/post/filters/DepthOfFieldFilter.java
index 238fe067e..b360e5c66 100644
--- a/engine/src/desktop-fx/com/jme3/post/filters/DepthOfFieldFilter.java
+++ b/engine/src/desktop-fx/com/jme3/post/filters/DepthOfFieldFilter.java
@@ -35,7 +35,6 @@ import com.jme3.asset.AssetManager;
import com.jme3.post.Filter;
import com.jme3.material.Material;
import com.jme3.renderer.RenderManager;
-import com.jme3.renderer.Renderer;
import com.jme3.renderer.ViewPort;
/**
@@ -55,28 +54,31 @@ public class DepthOfFieldFilter extends Filter {
private float xScale;
private float yScale;
+ /**
+ * Creates a DepthOfField filter
+ */
public DepthOfFieldFilter() {
super("Depth Of Field");
}
@Override
- public boolean isRequiresDepthTexture() {
+ protected boolean isRequiresDepthTexture() {
return true;
}
@Override
- public Material getMaterial() {
+ protected Material getMaterial() {
return material;
}
@Override
- public void initFilter(AssetManager assets, RenderManager renderManager,
+ protected void initFilter(AssetManager assets, RenderManager renderManager,
ViewPort vp, int w, int h) {
material = new Material(assets, "Common/MatDefs/Post/DepthOfField.j3md");
material.setFloat("FocusDistance", focusDistance);
material.setFloat("FocusRange", focusRange);
-
+
xScale = 1.0f / w;
yScale = 1.0f / h;
@@ -85,10 +87,6 @@ public class DepthOfFieldFilter extends Filter {
material.setFloat("YScale", blurScale * yScale);
}
- @Override
- public void cleanUpFilter(Renderer r) {
- }
-
/**
* Sets the distance at which objects are purely in focus.
*/
@@ -101,6 +99,10 @@ public class DepthOfFieldFilter extends Filter {
}
+ /**
+ * returns the focus distance
+ * @return
+ */
public float getFocusDistance() {
return focusDistance;
}
@@ -118,6 +120,10 @@ public class DepthOfFieldFilter extends Filter {
}
+ /**
+ * returns the focus range
+ * @return
+ */
public float getFocusRange() {
return focusRange;
}
@@ -142,6 +148,10 @@ public class DepthOfFieldFilter extends Filter {
}
}
+ /**
+ * returns the blur scale
+ * @return
+ */
public float getBlurScale() {
return blurScale;
}
diff --git a/engine/src/desktop-fx/com/jme3/post/filters/FadeFilter.java b/engine/src/desktop-fx/com/jme3/post/filters/FadeFilter.java
index 9832c833a..bf5a84104 100644
--- a/engine/src/desktop-fx/com/jme3/post/filters/FadeFilter.java
+++ b/engine/src/desktop-fx/com/jme3/post/filters/FadeFilter.java
@@ -39,13 +39,13 @@ import com.jme3.export.OutputCapsule;
import com.jme3.material.Material;
import com.jme3.post.Filter;
import com.jme3.renderer.RenderManager;
-import com.jme3.renderer.Renderer;
import com.jme3.renderer.ViewPort;
import java.io.IOException;
/**
*
- * @author Nehon
+ * Fade Filter allows you to make an animated fade effect on a scene.
+ * @author Rémy Bouquet aka Nehon
* implemented from boxjar implementation
* see http://jmonkeyengine.org/groups/graphics/forum/topic/newbie-question-general-fade-inout-effect/#post-105559
*/
@@ -56,29 +56,35 @@ public class FadeFilter extends Filter {
private float direction = 1;
private float duration = 1;
+ /**
+ * Creates a FadeFilter
+ */
public FadeFilter() {
super("Fade In/Out");
}
+ /**
+ * Creates a FadeFilter with the given duration
+ * @param duration
+ */
public FadeFilter(float duration) {
this();
this.duration = duration;
}
@Override
- public Material getMaterial() {
+ protected Material getMaterial() {
material.setFloat("Value", value);
return material;
}
-
@Override
- public void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
+ protected void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
material = new Material(manager, "Common/MatDefs/Post/Fade.j3md");
}
@Override
- public void preFrame(float tpf) {
+ protected void preFrame(float tpf) {
if (playing) {
value += tpf * direction / duration;
@@ -95,20 +101,34 @@ public class FadeFilter extends Filter {
}
}
+ /**
+ * returns the duration of the effect
+ * @return
+ */
public float getDuration() {
return duration;
}
+ /**
+ * Sets the duration of the filter default is 1 second
+ * @param duration
+ */
public void setDuration(float duration) {
this.duration = duration;
}
+ /**
+ * fades the scene in (black to scene)
+ */
public void fadeIn() {
setEnabled(true);
direction = 1;
playing = true;
}
+ /**
+ * fades the scene out (scene to black)
+ */
public void fadeOut() {
setEnabled(true);
direction = -1;
@@ -130,15 +150,21 @@ public class FadeFilter extends Filter {
duration = ic.readFloat("duration", 1);
}
+ /**
+ * return the current value of the fading
+ * can be used to chack if fade is complete (eg value=1)
+ * @return
+ */
public float getValue() {
return value;
}
+ /**
+ * sets the fade value
+ * can be used to force complete black or compete scene
+ * @param value
+ */
public void setValue(float value) {
this.value = value;
}
-
- @Override
- public void cleanUpFilter(Renderer r) {
- }
}
diff --git a/engine/src/desktop-fx/com/jme3/post/filters/FogFilter.java b/engine/src/desktop-fx/com/jme3/post/filters/FogFilter.java
index b075476b9..ff617970a 100644
--- a/engine/src/desktop-fx/com/jme3/post/filters/FogFilter.java
+++ b/engine/src/desktop-fx/com/jme3/post/filters/FogFilter.java
@@ -40,13 +40,12 @@ import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.post.Filter;
import com.jme3.renderer.RenderManager;
-import com.jme3.renderer.Renderer;
import com.jme3.renderer.ViewPort;
import java.io.IOException;
/**
* A filter to render a fog effect
- * @author Nehon
+ * @author Rémy Bouquet aka Nehon
*/
public class FogFilter extends Filter {
@@ -54,6 +53,9 @@ public class FogFilter extends Filter {
private float fogDensity = 0.7f;
private float fogDistance = 1000;
+ /**
+ * Creates a FogFilter
+ */
public FogFilter() {
super("FogFilter");
}
@@ -72,12 +74,12 @@ public class FogFilter extends Filter {
}
@Override
- public boolean isRequiresDepthTexture() {
+ protected boolean isRequiresDepthTexture() {
return true;
}
@Override
- public void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
+ protected void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
material = new Material(manager, "Common/MatDefs/Post/Fog.j3md");
material.setColor("FogColor", fogColor);
material.setFloat("FogDensity", fogDensity);
@@ -85,7 +87,7 @@ public class FogFilter extends Filter {
}
@Override
- public Material getMaterial() {
+ protected Material getMaterial() {
return material;
}
@@ -166,7 +168,5 @@ public class FogFilter extends Filter {
fogDistance = ic.readFloat("fogDistance", 1000);
}
- @Override
- public void cleanUpFilter(Renderer r) {
- }
+
}
diff --git a/engine/src/desktop-fx/com/jme3/post/filters/LightScatteringFilter.java b/engine/src/desktop-fx/com/jme3/post/filters/LightScatteringFilter.java
index 0056506d7..953f10a66 100644
--- a/engine/src/desktop-fx/com/jme3/post/filters/LightScatteringFilter.java
+++ b/engine/src/desktop-fx/com/jme3/post/filters/LightScatteringFilter.java
@@ -41,13 +41,14 @@ import com.jme3.math.Vector3f;
import com.jme3.post.Filter;
import com.jme3.renderer.Camera;
import com.jme3.renderer.RenderManager;
-import com.jme3.renderer.Renderer;
import com.jme3.renderer.ViewPort;
import java.io.IOException;
/**
+ * LightScattering filters creates rays comming from a light sources
+ * This is often reffered as god rays.
*
- * @author nehon
+ * @author Rémy Bouquet aka Nehon
*/
public class LightScatteringFilter extends Filter {
@@ -59,25 +60,32 @@ public class LightScatteringFilter extends Filter {
private float lightDensity = 1.4f;
private boolean adaptative = true;
Vector3f viewLightPos = new Vector3f();
- private boolean display=true;
+ private boolean display = true;
private float innerLightDensity;
+ /**
+ * creates a lightScaterring filter
+ */
public LightScatteringFilter() {
super("Light Scattering");
}
+ /**
+ * Creates a lightScatteringFilter
+ * @param lightPosition
+ */
public LightScatteringFilter(Vector3f lightPosition) {
this();
this.lightPosition = lightPosition;
}
@Override
- public boolean isRequiresDepthTexture() {
+ protected boolean isRequiresDepthTexture() {
return true;
}
@Override
- public Material getMaterial() {
+ protected Material getMaterial() {
material.setVector3("LightPosition", screenLightPos);
material.setInt("NbSamples", nbSamples);
material.setFloat("BlurStart", blurStart);
@@ -88,7 +96,7 @@ public class LightScatteringFilter extends Filter {
}
@Override
- public void postQueue(RenderManager renderManager, ViewPort viewPort) {
+ protected void postQueue(RenderManager renderManager, ViewPort viewPort) {
getClipCoordinates(lightPosition, screenLightPos, viewPort.getCamera());
// screenLightPos.x = screenLightPos.x / viewPort.getCamera().getWidth();
// screenLightPos.y = screenLightPos.y / viewPort.getCamera().getHeight();
@@ -101,12 +109,12 @@ public class LightScatteringFilter extends Filter {
//System.err.println("screenLightPos "+screenLightPos);
if (adaptative) {
innerLightDensity = Math.max(lightDensity - Math.max(screenLightPos.x, screenLightPos.y), 0.0f);
- }else{
- innerLightDensity=lightDensity;
+ } else {
+ innerLightDensity = lightDensity;
}
}
- public Vector3f getClipCoordinates(Vector3f worldPosition, Vector3f store, Camera cam) {
+ private Vector3f getClipCoordinates(Vector3f worldPosition, Vector3f store, Camera cam) {
float w = cam.getViewProjectionMatrix().multProj(worldPosition, store);
store.divideLocal(w);
@@ -119,46 +127,92 @@ public class LightScatteringFilter extends Filter {
}
@Override
- public void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
+ protected void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
material = new Material(manager, "Common/MatDefs/Post/LightScattering.j3md");
}
+ /**
+ * returns the blur start of the scattering
+ * see {@link setBlurStart(float blurStart)}
+ * @return
+ */
public float getBlurStart() {
return blurStart;
}
+ /**
+ * sets the blur start
+ * at which distance from the light source the effect starts default is 0.02
+ * @param blurStart
+ */
public void setBlurStart(float blurStart) {
this.blurStart = blurStart;
}
+ /**
+ * returns the blur width
+ * see {@link setBlurWidth(float blurWidth)}
+ * @return
+ */
public float getBlurWidth() {
return blurWidth;
}
+ /**
+ * sets the blur width default is 0.9
+ * @param blurWidth
+ */
public void setBlurWidth(float blurWidth) {
this.blurWidth = blurWidth;
}
+ /**
+ * retiurns the light density
+ * see {@link setLightDensity(float lightDensity)}
+ *
+ * @return
+ */
public float getLightDensity() {
return lightDensity;
}
+ /**
+ * sets how much the effect is visible over the rendered scene default is 1.4
+ * @param lightDensity
+ */
public void setLightDensity(float lightDensity) {
this.lightDensity = lightDensity;
}
+ /**
+ * returns the light position
+ * @return
+ */
public Vector3f getLightPosition() {
return lightPosition;
}
+ /**
+ * sets the light position
+ * @param lightPosition
+ */
public void setLightPosition(Vector3f lightPosition) {
this.lightPosition = lightPosition;
}
+ /**
+ * returns the nmber of samples for the radial blur
+ * @return
+ */
public int getNbSamples() {
return nbSamples;
}
+ /**
+ * sets the number of samples for the radial blur default is 50
+ * the higher the value the higher the quality, but the slower the performances.
+ * @param nbSamples
+ */
public void setNbSamples(int nbSamples) {
this.nbSamples = nbSamples;
}
@@ -186,8 +240,4 @@ public class LightScatteringFilter extends Filter {
lightDensity = ic.readFloat("lightDensity", 1.4f);
adaptative = ic.readBoolean("adaptative", true);
}
-
- @Override
- public void cleanUpFilter(Renderer r) {
- }
}
diff --git a/engine/src/desktop-fx/com/jme3/post/filters/PosterizationFilter.java b/engine/src/desktop-fx/com/jme3/post/filters/PosterizationFilter.java
index 6a9814367..c980edaee 100644
--- a/engine/src/desktop-fx/com/jme3/post/filters/PosterizationFilter.java
+++ b/engine/src/desktop-fx/com/jme3/post/filters/PosterizationFilter.java
@@ -35,7 +35,6 @@ import com.jme3.asset.AssetManager;
import com.jme3.material.Material;
import com.jme3.post.Filter;
import com.jme3.renderer.RenderManager;
-import com.jme3.renderer.Renderer;
import com.jme3.renderer.ViewPort;
/**
@@ -56,27 +55,34 @@ public class PosterizationFilter extends Filter {
private float gamma = 0.6f;
private float strength = 1.0f;
+ /**
+ * Creates a posterization Filter
+ */
public PosterizationFilter() {
super("PosterizationFilter");
}
+ /**
+ * Creates a posterization Filter with the given number of colors
+ * @param numColors
+ */
public PosterizationFilter(int numColors) {
this();
this.numColors = numColors;
}
+ /**
+ * Creates a posterization Filter with the given number of colors and gamma
+ * @param numColors
+ * @param gamma
+ */
public PosterizationFilter(int numColors, float gamma) {
this(numColors);
this.gamma = gamma;
}
@Override
- public boolean isRequiresDepthTexture() {
- return false;
- }
-
- @Override
- public void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
+ protected void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
material = new Material(manager, "Common/MatDefs/Post/Posterization.j3md");
material.setInt("NumColors", numColors);
material.setFloat("Gamma", gamma);
@@ -84,16 +90,11 @@ public class PosterizationFilter extends Filter {
}
@Override
- public Material getMaterial() {
+ protected Material getMaterial() {
return material;
}
-
- @Override
- public void cleanUpFilter(Renderer r) {
- }
-
- /*
+ /**
* Sets number of color levels used to draw the screen
*/
public void setNumColors(int numColors) {
@@ -103,7 +104,7 @@ public class PosterizationFilter extends Filter {
}
}
- /*
+ /**
* Sets gamma level used to enhange visual quality
*/
public void setGamma(float gamma) {
@@ -113,7 +114,7 @@ public class PosterizationFilter extends Filter {
}
}
- /*
+ /**
* Sets urrent strength value, i.e. influence on final image
*/
public void setStrength(float strength) {
@@ -123,21 +124,21 @@ public class PosterizationFilter extends Filter {
}
}
- /*
+ /**
* Returns number of color levels used
*/
public int getNumColors() {
return numColors;
}
- /*
+ /**
* Returns current gamma value
*/
public float getGamma() {
return gamma;
}
- /*
+ /**
* Returns current strength value, i.e. influence on final image
*/
public float getStrength() {
diff --git a/engine/src/desktop-fx/com/jme3/post/filters/RadialBlurFilter.java b/engine/src/desktop-fx/com/jme3/post/filters/RadialBlurFilter.java
index e52b2398c..db0b4ed5f 100644
--- a/engine/src/desktop-fx/com/jme3/post/filters/RadialBlurFilter.java
+++ b/engine/src/desktop-fx/com/jme3/post/filters/RadialBlurFilter.java
@@ -39,14 +39,13 @@ import com.jme3.export.OutputCapsule;
import com.jme3.material.Material;
import com.jme3.post.Filter;
import com.jme3.renderer.RenderManager;
-import com.jme3.renderer.Renderer;
import com.jme3.renderer.ViewPort;
import com.jme3.shader.VarType;
import java.io.IOException;
/**
- *
- * @author nehon
+ * Radially blurs the scene from the center of it
+ * @author Rémy Bouquet aka Nehon
*/
public class RadialBlurFilter extends Filter {
@@ -54,10 +53,18 @@ public class RadialBlurFilter extends Filter {
private float sampleStrength = 2.2f;
private float[] samples = {-0.08f, -0.05f, -0.03f, -0.02f, -0.01f, 0.01f, 0.02f, 0.03f, 0.05f, 0.08f};
+ /**
+ * Creates a RadialBlurFilter
+ */
public RadialBlurFilter() {
super("Radial blur");
}
+ /**
+ * Creates a RadialBlurFilter
+ * @param sampleDist the distance between samples
+ * @param sampleStrength the strenght of each sample
+ */
public RadialBlurFilter(float sampleDist, float sampleStrength) {
this();
this.sampleDist = sampleDist;
@@ -65,7 +72,7 @@ public class RadialBlurFilter extends Filter {
}
@Override
- public Material getMaterial() {
+ protected Material getMaterial() {
material.setFloat("SampleDist", sampleDist);
material.setFloat("SampleStrength", sampleStrength);
@@ -74,25 +81,60 @@ public class RadialBlurFilter extends Filter {
return material;
}
+ /**
+ * return the sample distance
+ * @return
+ */
+ public float getSampleDistance() {
+ return sampleDist;
+ }
+ /**
+ * sets the samples distances default is 1
+ * @param sampleDist
+ */
+ public void setSampleDistance(float sampleDist) {
+ this.sampleDist = sampleDist;
+ }
+
+ /**
+ *
+ * @return
+ * @deprecated use {@link getSampleDistance()}
+ */
+ @Deprecated
public float getSampleDist() {
return sampleDist;
}
+ /**
+ *
+ * @param sampleDist
+ * @deprecated use {@link setSampleDistance(float sampleDist)}
+ */
+ @Deprecated
public void setSampleDist(float sampleDist) {
this.sampleDist = sampleDist;
}
+ /**
+ * Returns the sample Strength
+ * @return
+ */
public float getSampleStrength() {
return sampleStrength;
}
+ /**
+ * sets the sample streanght default is 2.2
+ * @param sampleStrength
+ */
public void setSampleStrength(float sampleStrength) {
this.sampleStrength = sampleStrength;
}
@Override
- public void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
+ protected void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
material = new Material(manager, "Common/MatDefs/Blur/RadialBlur.j3md");
}
@@ -111,8 +153,4 @@ public class RadialBlurFilter extends Filter {
sampleDist = ic.readFloat("sampleDist", 1.0f);
sampleStrength = ic.readFloat("sampleStrength", 2.2f);
}
-
- @Override
- public void cleanUpFilter(Renderer r) {
- }
}
diff --git a/engine/src/desktop-fx/com/jme3/post/filters/TranslucentBucketFilter.java b/engine/src/desktop-fx/com/jme3/post/filters/TranslucentBucketFilter.java
index 12016d485..47be41382 100644
--- a/engine/src/desktop-fx/com/jme3/post/filters/TranslucentBucketFilter.java
+++ b/engine/src/desktop-fx/com/jme3/post/filters/TranslucentBucketFilter.java
@@ -16,7 +16,8 @@ import com.jme3.texture.FrameBuffer;
import com.jme3.texture.Texture2D;
/**
- *
+ * A filter to handle translucent objects when rendering a scene with filters that uses depth like WaterFilter and SSAOFilter
+ * just create a TranslucentBucketFilter and add it to the Filter list of a FilterPostPorcessor
* @author Nehon
*/
public final class TranslucentBucketFilter extends Filter {
@@ -24,7 +25,7 @@ public final class TranslucentBucketFilter extends Filter {
private RenderManager renderManager;
@Override
- public void initFilter(AssetManager manager, RenderManager rm, ViewPort vp, int w, int h) {
+ protected void initFilter(AssetManager manager, RenderManager rm, ViewPort vp, int w, int h) {
this.renderManager = rm;
material = new Material(manager, "Common/MatDefs/Post/Overlay.j3md");
material.setColor("Color", ColorRGBA.White);
@@ -37,19 +38,20 @@ public final class TranslucentBucketFilter extends Filter {
}
renderManager.setHandleTranslucentBucket(false);
}
-
- /**
+
+ /**
* Override this method and return false if your Filter does not need the scene texture
* @return
*/
- public boolean isRequiresSceneTexture() {
+ @Override
+ protected boolean isRequiresSceneTexture() {
return false;
}
@Override
- public void postFrame(RenderManager renderManager, ViewPort viewPort, FrameBuffer prevFilterBuffer, FrameBuffer sceneBuffer) {
+ protected void postFrame(RenderManager renderManager, ViewPort viewPort, FrameBuffer prevFilterBuffer, FrameBuffer sceneBuffer) {
renderManager.setCamera(viewPort.getCamera(), false);
- if(prevFilterBuffer != sceneBuffer){
+ if (prevFilterBuffer != sceneBuffer) {
renderManager.getRenderer().copyFrameBuffer(prevFilterBuffer, sceneBuffer, false);
}
renderManager.getRenderer().setFrameBuffer(sceneBuffer);
@@ -57,14 +59,14 @@ public final class TranslucentBucketFilter extends Filter {
}
@Override
- public void cleanUpFilter(Renderer r) {
+ protected void cleanUpFilter(Renderer r) {
if (renderManager != null) {
renderManager.setHandleTranslucentBucket(true);
}
}
@Override
- public Material getMaterial() {
+ protected Material getMaterial() {
return material;
}
diff --git a/engine/src/desktop-fx/com/jme3/post/ssao/SSAOFilter.java b/engine/src/desktop-fx/com/jme3/post/ssao/SSAOFilter.java
index a2281ec5a..fc5fdd6e1 100644
--- a/engine/src/desktop-fx/com/jme3/post/ssao/SSAOFilter.java
+++ b/engine/src/desktop-fx/com/jme3/post/ssao/SSAOFilter.java
@@ -96,12 +96,12 @@ public class SSAOFilter extends Filter {
}
@Override
- public boolean isRequiresDepthTexture() {
+ protected boolean isRequiresDepthTexture() {
return true;
}
@Override
- public void postQueue(RenderManager renderManager, ViewPort viewPort) {
+ protected void postQueue(RenderManager renderManager, ViewPort viewPort) {
Renderer r = renderManager.getRenderer();
r.setFrameBuffer(normalPass.getRenderFrameBuffer());
renderManager.getRenderer().clearBuffers(true, true, true);
@@ -112,12 +112,12 @@ public class SSAOFilter extends Filter {
}
@Override
- public Material getMaterial() {
+ protected Material getMaterial() {
return material;
}
@Override
- public void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
+ protected void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
int screenWidth = w;
int screenHeight = h;
postRenderPasses = new ArrayList();
@@ -270,7 +270,5 @@ public class SSAOFilter extends Filter {
bias = ic.readFloat("bias", 0.1f);
}
- @Override
- public void cleanUpFilter(Renderer r) {
- }
+
}
diff --git a/engine/src/desktop-fx/com/jme3/water/WaterFilter.java b/engine/src/desktop-fx/com/jme3/water/WaterFilter.java
index 49927b00a..2f35f6e98 100644
--- a/engine/src/desktop-fx/com/jme3/water/WaterFilter.java
+++ b/engine/src/desktop-fx/com/jme3/water/WaterFilter.java
@@ -112,7 +112,6 @@ public class WaterFilter extends Filter {
private boolean underWater;
private float underWaterFogDistance = 120;
private float causticsIntensity = 0.5f;
-
private RenderManager renderManager;
private ViewPort viewPort;
@@ -130,12 +129,12 @@ public class WaterFilter extends Filter {
}
@Override
- public boolean isRequiresDepthTexture() {
+ protected boolean isRequiresDepthTexture() {
return true;
}
@Override
- public void preFrame(float tpf) {
+ protected void preFrame(float tpf) {
time = time + (tpf * speed);
material.setFloat("Time", time);
Camera sceneCam = viewPort.getCamera();
@@ -172,7 +171,7 @@ public class WaterFilter extends Filter {
float planeDistance = plane.pseudoDistance(vars.vect1);
vars.vect2.set(plane.getNormal()).multLocal(planeDistance * 2.0f);
vars.vect3.set(vars.vect1.subtractLocal(vars.vect2)).subtractLocal(loc).normalizeLocal().negateLocal();
-
+
reflectionCam.lookAt(targetLocation, vars.vect3);
assert vars.unlock();
@@ -193,8 +192,8 @@ public class WaterFilter extends Filter {
}
renderManager.setCamera(sceneCam, false);
renderManager.getRenderer().setFrameBuffer(viewPort.getOutputFrameBuffer());
-
-
+
+
underWater = false;
} else {
underWater = true;
@@ -202,21 +201,14 @@ public class WaterFilter extends Filter {
}
@Override
- public void init(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
- super.init(manager, renderManager, vp, w, h);
- this.renderManager=renderManager;
- this.viewPort=vp;
- }
-
-
- @Override
- public Material getMaterial() {
+ protected Material getMaterial() {
return material;
}
@Override
- public void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
-
+ protected void initFilter(AssetManager manager, RenderManager renderManager, ViewPort vp, int w, int h) {
+ this.renderManager = renderManager;
+ this.viewPort = vp;
reflectionPass = new Pass();
reflectionPass.init(renderManager.getRenderer(), reflectionMapSize, reflectionMapSize, Format.RGBA8, Format.Depth);
reflectionCam = new Camera(reflectionMapSize, reflectionMapSize);
@@ -746,13 +738,6 @@ public class WaterFilter extends Filter {
this.reflectionMapSize = reflectionMapSize;
}
- @Override
- public void cleanUpFilter(Renderer r) {
- if (reflectionPass != null) {
- reflectionPass.cleanup(r);
- }
- }
-
/**
* returns true if the water uses foam
* @return