sigonasr2
/
jmonkeyengine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

correct core comments and standardize line endings as discussed at http://hub.jmonkeyengine.org/forum/topic/typos-in-com-jme3-mathrendererpost/

Browse Source
experimental
sgold@sonic.net 11 years ago
parent a2855c1cf0
commit 98ffe52c77
6 changed files with 2185 additions and 2183 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 1190
      jme3-core/src/main/java/com/jme3/math/ColorRGBA.java
  2. 329
      jme3-core/src/main/java/com/jme3/math/CurveAndSurfaceMath.java
  3. 1919
      jme3-core/src/main/java/com/jme3/math/FastMath.java
  4. 912
      jme3-core/src/main/java/com/jme3/post/Filter.java
  5. 16
      jme3-core/src/main/java/com/jme3/renderer/Camera.java
  6. 2
      jme3-core/src/main/java/com/jme3/renderer/Renderer.java

1190
jme3-core/src/main/java/com/jme3/math/ColorRGBA.java
View File

File diff suppressed because it is too large Load Diff

329
jme3-core/src/main/java/com/jme3/math/CurveAndSurfaceMath.java
Unescape View File

@ -1,164 +1,165 @@
/*
* Copyright (c) 2009-2012 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.math;
import com.jme3.math.Spline.SplineType;
import java.util.List;
/**
* This class offers methods to help with curves and surfaces calculations.
* @author Marcin Roguski (Kealthas)
*/
public class CurveAndSurfaceMath {
private static final float KNOTS_MINIMUM_DELTA = 0.0001f;
/**
* A private constructor is defined to avoid instatiation of this class.
*/
private CurveAndSurfaceMath() {}
/**
* This method interpolates tha data for the nurbs curve.
* @param u
* the u value
* @param nurbSpline
* the nurbs spline definition
* @param store
* the resulting point in 3D space
*/
public static void interpolateNurbs(float u, Spline nurbSpline, Vector3f store) {
if (nurbSpline.getType() != SplineType.Nurb) {
throw new IllegalArgumentException("Given spline is not of a NURB type!");
}
List<Vector3f> controlPoints = nurbSpline.getControlPoints();
float[] weights = nurbSpline.getWeights();
List<Float> knots = nurbSpline.getKnots();
int controlPointAmount = controlPoints.size();
store.set(Vector3f.ZERO);
float delimeter = 0;
for (int i = 0; i < controlPointAmount; ++i) {
float val = weights[i] * CurveAndSurfaceMath.computeBaseFunctionValue(i, nurbSpline.getBasisFunctionDegree(), u, knots);
store.addLocal(nurbSpline.getControlPoints().get(i)
.mult(val));
delimeter += val;
}
store.divideLocal(delimeter);
}
/**
* This method interpolates tha data for the nurbs surface.
*
* @param u
* the u value
* @param v
* the v value
* @param controlPoints
* the nurbs' control points
* @param knots
* the nurbs' knots
* @param basisUFunctionDegree
* the degree of basis U function
* @param basisVFunctionDegree
* the degree of basis V function
* @param store
* the resulting point in 3D space
*/
public static void interpolate(float u, float v, List<List<Vector4f>> controlPoints, List<Float>[] knots,
int basisUFunctionDegree, int basisVFunctionDegree, Vector3f store) {
store.set(Vector3f.ZERO);
float delimeter = 0;
int vControlPointsAmount = controlPoints.size();
int uControlPointsAmount = controlPoints.get(0).size();
for (int i = 0; i < vControlPointsAmount; ++i) {
for (int j = 0; j < uControlPointsAmount; ++j) {
Vector4f controlPoint = controlPoints.get(i).get(j);
float val = controlPoint.w
* CurveAndSurfaceMath.computeBaseFunctionValue(i, basisVFunctionDegree, v, knots[1])
* CurveAndSurfaceMath.computeBaseFunctionValue(j, basisUFunctionDegree, u, knots[0]);
store.addLocal(controlPoint.x * val, controlPoint.y * val, controlPoint.z * val);
delimeter += val;
}
}
store.divideLocal(delimeter);
}
/**
* This method prepares the knots to be used. If the knots represent non-uniform B-splines (first and last knot values are being
* repeated) it leads to NaN results during calculations. This method adds a small number to each of such knots to avoid NaN's.
* @param knots
* the knots to be prepared to use
* @param basisFunctionDegree
* the degree of basis function
*/
// TODO: improve this; constant delta may lead to errors if the difference between tha last repeated
// point and the following one is lower than it
public static void prepareNurbsKnots(List<Float> knots, int basisFunctionDegree) {
float delta = KNOTS_MINIMUM_DELTA;
float prevValue = knots.get(0).floatValue();
for(int i=1;i<knots.size();++i) {
float value = knots.get(i).floatValue();
if(value<=prevValue) {
value += delta;
knots.set(i, Float.valueOf(value));
delta += KNOTS_MINIMUM_DELTA;
} else {
delta = KNOTS_MINIMUM_DELTA;//reset the delta's value
}
prevValue = value;
}
}
/**
* This method computes the base function value for the NURB curve.
* @param i
* the knot index
* @param k
* the base function degree
* @param t
* the knot value
* @param knots
* the knots' values
* @return the base function value
*/
private static float computeBaseFunctionValue(int i, int k, float t, List<Float> knots) {
if (k == 1) {
return knots.get(i) <= t && t < knots.get(i + 1) ? 1.0f : 0.0f;
} else {
return (t - knots.get(i)) / (knots.get(i + k - 1) - knots.get(i)) *
CurveAndSurfaceMath.computeBaseFunctionValue(i, k - 1, t, knots)
+ (knots.get(i + k) - t) / (knots.get(i + k) - knots.get(i + 1)) *
CurveAndSurfaceMath.computeBaseFunctionValue(i + 1, k - 1, t, knots);
}
}
}
/*
* Copyright (c) 2009-2012 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.math;
import com.jme3.math.Spline.SplineType;
import java.util.List;
/**
* This class offers methods to help with curves and surfaces calculations.
* @author Marcin Roguski (Kealthas)
*/
public class CurveAndSurfaceMath {
private static final float KNOTS_MINIMUM_DELTA = 0.0001f;
/**
* A private constructor is defined to avoid instantiation of this
* class.
*/
private CurveAndSurfaceMath() {}
/**
* This method interpolates the data for the nurbs curve.
* @param u
* the u value
* @param nurbSpline
* the nurbs spline definition
* @param store
* the resulting point in 3D space
*/
public static void interpolateNurbs(float u, Spline nurbSpline, Vector3f store) {
if (nurbSpline.getType() != SplineType.Nurb) {
throw new IllegalArgumentException("Given spline is not of a NURB type!");
}
List<Vector3f> controlPoints = nurbSpline.getControlPoints();
float[] weights = nurbSpline.getWeights();
List<Float> knots = nurbSpline.getKnots();
int controlPointAmount = controlPoints.size();
store.set(Vector3f.ZERO);
float delimeter = 0;
for (int i = 0; i < controlPointAmount; ++i) {
float val = weights[i] * CurveAndSurfaceMath.computeBaseFunctionValue(i, nurbSpline.getBasisFunctionDegree(), u, knots);
store.addLocal(nurbSpline.getControlPoints().get(i)
.mult(val));
delimeter += val;
}
store.divideLocal(delimeter);
}
/**
* This method interpolates the data for the nurbs surface.
*
* @param u
* the u value
* @param v
* the v value
* @param controlPoints
* the nurbs' control points
* @param knots
* the nurbs' knots
* @param basisUFunctionDegree
* the degree of basis U function
* @param basisVFunctionDegree
* the degree of basis V function
* @param store
* the resulting point in 3D space
*/
public static void interpolate(float u, float v, List<List<Vector4f>> controlPoints, List<Float>[] knots,
int basisUFunctionDegree, int basisVFunctionDegree, Vector3f store) {
store.set(Vector3f.ZERO);
float delimeter = 0;
int vControlPointsAmount = controlPoints.size();
int uControlPointsAmount = controlPoints.get(0).size();
for (int i = 0; i < vControlPointsAmount; ++i) {
for (int j = 0; j < uControlPointsAmount; ++j) {
Vector4f controlPoint = controlPoints.get(i).get(j);
float val = controlPoint.w
* CurveAndSurfaceMath.computeBaseFunctionValue(i, basisVFunctionDegree, v, knots[1])
* CurveAndSurfaceMath.computeBaseFunctionValue(j, basisUFunctionDegree, u, knots[0]);
store.addLocal(controlPoint.x * val, controlPoint.y * val, controlPoint.z * val);
delimeter += val;
}
}
store.divideLocal(delimeter);
}
/**
* This method prepares the knots to be used. If the knots represent non-uniform B-splines (first and last knot values are being
* repeated) it leads to NaN results during calculations. This method adds a small number to each of such knots to avoid NaN's.
* @param knots
* the knots to be prepared to use
* @param basisFunctionDegree
* the degree of basis function
*/
// TODO: improve this; constant delta may lead to errors if the difference between tha last repeated
// point and the following one is lower than it
public static void prepareNurbsKnots(List<Float> knots, int basisFunctionDegree) {
float delta = KNOTS_MINIMUM_DELTA;
float prevValue = knots.get(0).floatValue();
for(int i=1;i<knots.size();++i) {
float value = knots.get(i).floatValue();
if(value<=prevValue) {
value += delta;
knots.set(i, Float.valueOf(value));
delta += KNOTS_MINIMUM_DELTA;
} else {
delta = KNOTS_MINIMUM_DELTA;//reset the delta's value
}
prevValue = value;
}
}
/**
* This method computes the base function value for the NURB curve.
* @param i
* the knot index
* @param k
* the base function degree
* @param t
* the knot value
* @param knots
* the knots' values
* @return the base function value
*/
private static float computeBaseFunctionValue(int i, int k, float t, List<Float> knots) {
if (k == 1) {
return knots.get(i) <= t && t < knots.get(i + 1) ? 1.0f : 0.0f;
} else {
return (t - knots.get(i)) / (knots.get(i + k - 1) - knots.get(i)) *
CurveAndSurfaceMath.computeBaseFunctionValue(i, k - 1, t, knots)
+ (knots.get(i + k) - t) / (knots.get(i + k) - knots.get(i + 1)) *
CurveAndSurfaceMath.computeBaseFunctionValue(i + 1, k - 1, t, knots);
}
}
}

1919
jme3-core/src/main/java/com/jme3/math/FastMath.java
View File

File diff suppressed because it is too large Load Diff

912
jme3-core/src/main/java/com/jme3/post/Filter.java
Unescape View File

@ -1,456 +1,456 @@
/*
* Copyright (c) 2009-2012 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.post;
import com.jme3.asset.AssetManager;
import com.jme3.export.*;
import com.jme3.material.Material;
import com.jme3.renderer.Caps;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.Renderer;
import com.jme3.renderer.ViewPort;
import com.jme3.renderer.queue.RenderQueue;
import com.jme3.texture.FrameBuffer;
import com.jme3.texture.Image.Format;
import com.jme3.texture.Texture;
import com.jme3.texture.Texture2D;
import java.io.IOException;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
/**
* Filters are 2D effects applied to the rendered scene.<br>
* The filter is fed with the rendered scene image rendered in an offscreen frame buffer.<br>
* This texture is applied on a fullscreen quad, with a special material.<br>
* This material uses a shader that aplly the desired effect to the scene texture.<br>
* <br>
* This class is abstract, any Filter must extend it.<br>
* Any filter holds a frameBuffer and a texture<br>
* The getMaterial must return a Material that use a GLSL shader immplementing the desired effect<br>
*
* @author Rémy Bouquet aka Nehon
*/
public abstract class Filter implements Savable {
private String name;
protected Pass defaultPass;
protected List<Pass> postRenderPasses;
protected Material material;
protected boolean enabled = true;
protected FilterPostProcessor processor;
public Filter(String name) {
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;
protected Texture2D renderedTexture;
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, boolean renderDepth) {
Collection<Caps> 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);
renderFrameBuffer.setDepthBuffer(depthBufferFormat);
if (renderDepth) {
depthTexture = new Texture2D(width, height, numSamples, depthBufferFormat);
renderFrameBuffer.setDepthTexture(depthTexture);
}
} else {
renderFrameBuffer = new FrameBuffer(width, height, 1);
renderedTexture = new Texture2D(width, height, textureFormat);
renderFrameBuffer.setDepthBuffer(depthBufferFormat);
if (renderDepth) {
depthTexture = new Texture2D(width, height, depthBufferFormat);
renderFrameBuffer.setDepthTexture(depthTexture);
}
}
renderFrameBuffer.setColorTexture(renderedTexture);
}
/**
* 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);
}
public void init(Renderer renderer, int width, int height, Format textureFormat, Format depthBufferFormat, int numSamples) {
init(renderer, width, height, textureFormat, depthBufferFormat, numSamples, false);
}
/**
* 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;
}
public boolean requiresSceneAsTexture() {
return false;
}
public boolean requiresDepthAsTexture() {
return false;
}
public void beforeRender() {
}
public FrameBuffer getRenderFrameBuffer() {
return renderFrameBuffer;
}
public void setRenderFrameBuffer(FrameBuffer renderFrameBuffer) {
this.renderFrameBuffer = renderFrameBuffer;
}
public Texture2D getDepthTexture() {
return depthTexture;
}
public Texture2D getRenderedTexture() {
return renderedTexture;
}
public void setRenderedTexture(Texture2D renderedTexture) {
this.renderedTexture = renderedTexture;
}
public Material getPassMaterial() {
return passMaterial;
}
public void setPassMaterial(Material passMaterial) {
this.passMaterial = passMaterial;
}
public void cleanup(Renderer r) {
renderFrameBuffer.dispose();
renderedTexture.getImage().dispose();
if(depthTexture!=null){
depthTexture.getImage().dispose();
}
}
}
/**
* 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;
}
/**
* contruct a Filter
*/
protected Filter() {
this("filter");
}
/**
*
* 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);
}
/**
* cleanup this filter
* @param r
*/
protected final void cleanup(Renderer r) {
processor = null;
if (defaultPass != null) {
defaultPass.cleanup(r);
}
if (postRenderPasses != null) {
for (Iterator<Pass> it = postRenderPasses.iterator(); it.hasNext();) {
Pass pass = it.next();
pass.cleanup(r);
}
}
cleanUpFilter(r);
}
/**
* 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
*/
protected void cleanUpFilter(Renderer r) {
}
/**
* Must return the material used for this filter.
* this method is called every frame.
*
* @return the material used for this filter.
*/
protected abstract Material getMaterial();
/**
* Override if you want to do something special with the depth texture;
* @param depthTexture
*/
protected void setDepthTexture(Texture depthTexture){
getMaterial().setTexture("DepthTexture", depthTexture);
}
/**
* Override this method if you want to make a pre pass, before the actual rendering of the frame
* @param queue
*/
protected void postQueue(RenderQueue queue) {
}
/**
* 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
*/
protected void preFrame(float tpf) {
}
/**
* Override this method if you want to make a pass just after the frame has been rendered and just before the filter rendering
* @param renderManager
* @param viewPort
* @param prevFilterBuffer
* @param sceneBuffer
*/
protected void postFrame(RenderManager renderManager, ViewPort viewPort, FrameBuffer prevFilterBuffer, FrameBuffer sceneBuffer) {
}
/**
* Override this method if you want to save extra properties when the filter is saved else only basic properties of the filter will be saved
* This method should always begin by super.write(ex);
* @param ex
* @throws IOException
*/
public void write(JmeExporter ex) throws IOException {
OutputCapsule oc = ex.getCapsule(this);
oc.write(name, "name", "");
oc.write(enabled, "enabled", true);
}
/**
* Override this method if you want to load extra properties when the filter
* is loaded else only basic properties of the filter will be loaded
* This method should always begin by super.read(im);
*/
public void read(JmeImporter im) throws IOException {
InputCapsule ic = im.getCapsule(this);
name = ic.readString("name", "");
enabled = ic.readBoolean("enabled", true);
}
/**
* returns the name of the filter
* @return the Filter's name
*/
public String getName() {
return name;
}
/**
* Sets the name of the filter
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* returns the default pass frame buffer
* @return
*/
protected FrameBuffer getRenderFrameBuffer() {
return defaultPass.renderFrameBuffer;
}
/**
* sets the default pas frame buffer
* @param renderFrameBuffer
*/
protected void setRenderFrameBuffer(FrameBuffer renderFrameBuffer) {
this.defaultPass.renderFrameBuffer = renderFrameBuffer;
}
/**
* returns the rendered texture of this filter
* @return
*/
protected Texture2D getRenderedTexture() {
return defaultPass.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 needs the depth texture
*
* @return true if your Filter need the depth texture
*/
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
*/
protected boolean isRequiresSceneTexture() {
return true;
}
/**
* returns the list of the postRender passes
* @return
*/
protected List<Pass> getPostRenderPasses() {
return postRenderPasses;
}
/**
* Enable or disable this filter
* @param enabled true to enable
*/
public void setEnabled(boolean enabled) {
if (processor != null) {
processor.setFilterState(this, enabled);
} else {
this.enabled = enabled;
}
}
/**
* 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;
}
/**
* This method is called right after the filter has been rendered to the
* framebuffer.
* Note that buffer will be null if the filter is the last one in the stack
* and has been rendered to screen
* @param r the renderer
* @param buffer the framebuffer on hich the filtre has been rendered.
*/
protected void postFilter(Renderer r, FrameBuffer buffer){
}
}
/*
* Copyright (c) 2009-2012 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.post;
import com.jme3.asset.AssetManager;
import com.jme3.export.*;
import com.jme3.material.Material;
import com.jme3.renderer.Caps;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.Renderer;
import com.jme3.renderer.ViewPort;
import com.jme3.renderer.queue.RenderQueue;
import com.jme3.texture.FrameBuffer;
import com.jme3.texture.Image.Format;
import com.jme3.texture.Texture;
import com.jme3.texture.Texture2D;
import java.io.IOException;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
/**
* Filters are 2D effects applied to the rendered scene.<br>
* The filter is fed with the rendered scene image rendered in an offscreen frame buffer.<br>
* This texture is applied on a full-screen quad with a special material.<br>
* This material uses a shader that applies the desired effect to the scene texture.<br>
* <br>
* This class is abstract, any Filter must extend it.<br>
* Any filter holds a frameBuffer and a texture<br>
* The getMaterial must return a Material that use a GLSL shader implementing the desired effect<br>
*
* @author Rémy Bouquet aka Nehon
*/
public abstract class Filter implements Savable {
private String name;
protected Pass defaultPass;
protected List<Pass> postRenderPasses;
protected Material material;
protected boolean enabled = true;
protected FilterPostProcessor processor;
public Filter(String name) {
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;
protected Texture2D renderedTexture;
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, boolean renderDepth) {
Collection<Caps> 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);
renderFrameBuffer.setDepthBuffer(depthBufferFormat);
if (renderDepth) {
depthTexture = new Texture2D(width, height, numSamples, depthBufferFormat);
renderFrameBuffer.setDepthTexture(depthTexture);
}
} else {
renderFrameBuffer = new FrameBuffer(width, height, 1);
renderedTexture = new Texture2D(width, height, textureFormat);
renderFrameBuffer.setDepthBuffer(depthBufferFormat);
if (renderDepth) {
depthTexture = new Texture2D(width, height, depthBufferFormat);
renderFrameBuffer.setDepthTexture(depthTexture);
}
}
renderFrameBuffer.setColorTexture(renderedTexture);
}
/**
* 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);
}
public void init(Renderer renderer, int width, int height, Format textureFormat, Format depthBufferFormat, int numSamples) {
init(renderer, width, height, textureFormat, depthBufferFormat, numSamples, false);
}
/**
* 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;
}
public boolean requiresSceneAsTexture() {
return false;
}
public boolean requiresDepthAsTexture() {
return false;
}
public void beforeRender() {
}
public FrameBuffer getRenderFrameBuffer() {
return renderFrameBuffer;
}
public void setRenderFrameBuffer(FrameBuffer renderFrameBuffer) {
this.renderFrameBuffer = renderFrameBuffer;
}
public Texture2D getDepthTexture() {
return depthTexture;
}
public Texture2D getRenderedTexture() {
return renderedTexture;
}
public void setRenderedTexture(Texture2D renderedTexture) {
this.renderedTexture = renderedTexture;
}
public Material getPassMaterial() {
return passMaterial;
}
public void setPassMaterial(Material passMaterial) {
this.passMaterial = passMaterial;
}
public void cleanup(Renderer r) {
renderFrameBuffer.dispose();
renderedTexture.getImage().dispose();
if(depthTexture!=null){
depthTexture.getImage().dispose();
}
}
}
/**
* 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;
}
/**
* construct a Filter
*/
protected Filter() {
this("filter");
}
/**
*
* 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);
}
/**
* cleanup this filter
* @param r
*/
protected final void cleanup(Renderer r) {
processor = null;
if (defaultPass != null) {
defaultPass.cleanup(r);
}
if (postRenderPasses != null) {
for (Iterator<Pass> it = postRenderPasses.iterator(); it.hasNext();) {
Pass pass = it.next();
pass.cleanup(r);
}
}
cleanUpFilter(r);
}
/**
* 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
*/
protected void cleanUpFilter(Renderer r) {
}
/**
* Must return the material used for this filter.
* this method is called every frame.
*
* @return the material used for this filter.
*/
protected abstract Material getMaterial();
/**
* Override if you want to do something special with the depth texture;
* @param depthTexture
*/
protected void setDepthTexture(Texture depthTexture){
getMaterial().setTexture("DepthTexture", depthTexture);
}
/**
* Override this method if you want to make a pre pass, before the actual rendering of the frame
* @param queue
*/
protected void postQueue(RenderQueue queue) {
}
/**
* Override this method if you want to modify parameters according to tpf before the rendering of the frame.
* This is useful for animated filters
* Also it can be the place to render pre passes
* @param tpf the time used to render the previous frame
*/
protected void preFrame(float tpf) {
}
/**
* Override this method if you want to make a pass just after the frame has been rendered and just before the filter rendering
* @param renderManager
* @param viewPort
* @param prevFilterBuffer
* @param sceneBuffer
*/
protected void postFrame(RenderManager renderManager, ViewPort viewPort, FrameBuffer prevFilterBuffer, FrameBuffer sceneBuffer) {
}
/**
* Override this method if you want to save extra properties when the filter is saved else only basic properties of the filter will be saved
* This method should always begin by super.write(ex);
* @param ex
* @throws IOException
*/
public void write(JmeExporter ex) throws IOException {
OutputCapsule oc = ex.getCapsule(this);
oc.write(name, "name", "");
oc.write(enabled, "enabled", true);
}
/**
* Override this method if you want to load extra properties when the filter
* is loaded else only basic properties of the filter will be loaded
* This method should always begin by super.read(im);
*/
public void read(JmeImporter im) throws IOException {
InputCapsule ic = im.getCapsule(this);
name = ic.readString("name", "");
enabled = ic.readBoolean("enabled", true);
}
/**
* returns the name of the filter
* @return the Filter's name
*/
public String getName() {
return name;
}
/**
* Sets the name of the filter
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* returns the default pass frame buffer
* @return
*/
protected FrameBuffer getRenderFrameBuffer() {
return defaultPass.renderFrameBuffer;
}
/**
* sets the default pas frame buffer
* @param renderFrameBuffer
*/
protected void setRenderFrameBuffer(FrameBuffer renderFrameBuffer) {
this.defaultPass.renderFrameBuffer = renderFrameBuffer;
}
/**
* returns the rendered texture of this filter
* @return
*/
protected Texture2D getRenderedTexture() {
return defaultPass.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 needs the depth texture
*
* @return true if your Filter need the depth texture
*/
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
*/
protected boolean isRequiresSceneTexture() {
return true;
}
/**
* returns the list of the postRender passes
* @return
*/
protected List<Pass> getPostRenderPasses() {
return postRenderPasses;
}
/**
* Enable or disable this filter
* @param enabled true to enable
*/
public void setEnabled(boolean enabled) {
if (processor != null) {
processor.setFilterState(this, enabled);
} else {
this.enabled = enabled;
}
}
/**
* returns true 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;
}
/**
* This method is called right after the filter has been rendered to the
* framebuffer.
* Note that buffer will be null if the filter is the last one in the stack
* and has been rendered to screen
* @param r the renderer
* @param buffer the framebuffer on which the filter has been rendered.
*/
protected void postFilter(Renderer r, FrameBuffer buffer){
}
}

16
jme3-core/src/main/java/com/jme3/renderer/Camera.java
Unescape View File

@ -287,8 +287,8 @@ public class Camera implements Savable, Cloneable {
}
/**
* This method copise the settings of the given camera.
*
* This method copies the settings of the given camera.
*
* @param cam
* the camera we copy the settings from
*/
@ -368,8 +368,8 @@ public class Camera implements Savable, Cloneable {
/**
* Sets a clipPlane for this camera.
* The cliPlane is used to recompute the projectionMatrix using the plane as the near plane
* This technique is known as the oblique near-plane clipping method introduced by Eric Lengyel
* The clipPlane is used to recompute the
* projectionMatrix using the plane as the near plane * This technique is known as the oblique near-plane clipping method introduced by Eric Lengyel
* more info here
* <ul>
* <li><a href="http://www.terathon.com/code/oblique.html">http://www.terathon.com/code/oblique.html</a>
@ -668,8 +668,8 @@ public class Camera implements Savable, Cloneable {
}
/**
* <code>setRotation</code> sets the orientation of this camera.
* This will be equivelant to setting each of the axes:
* <code>setRotation</code> sets the orientation of this camera. This will
* be equivalent to setting each of the axes:
* <code><br>
* cam.setLeft(rotation.getRotationColumn(0));<br>
* cam.setUp(rotation.getRotationColumn(1));<br>
@ -803,7 +803,7 @@ public class Camera implements Savable, Cloneable {
}
/**
* <code>lookAt</code> is a convienence method for auto-setting the frame
* <code>lookAt</code> is a convenience method for auto-setting the frame
* based on a world position the user desires the camera to look at. It
* repoints the camera towards the given position using the difference
* between the position and the current camera location as a direction
@ -996,7 +996,7 @@ public class Camera implements Savable, Cloneable {
/**
* <code>contains</code> tests a bounding volume against the planes of the
* camera's frustum. The frustums planes are set such that the normals all
* camera's frustum. The frustum's planes are set such that the normals all
* face in towards the viewable scene. Therefore, if the bounding volume is
* on the negative side of the plane is can be culled out.
*

2
jme3-core/src/main/java/com/jme3/renderer/Renderer.java
Unescape View File

@ -269,7 +269,7 @@ public interface Renderer {
/**
* Renders <code>count</code> meshes, with the geometry data supplied.
* The shader which is currently set with <code>setShader</code> is
* responsible for transforming the input verticies into clip space
* responsible for transforming the input vertices into clip space
* and shading it based on the given vertex attributes.
* The int variable gl_InstanceID can be used to access the current
* instance of the mesh being rendered inside the vertex shader.

Write Preview
Loading…
Cancel
Save