Kirill Vainer
9 years ago
commit
ec9f8100c3
@ -0,0 +1,151 @@ |
||||
/* |
||||
* Copyright (c) 2009-2016 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.material; |
||||
|
||||
import com.jme3.export.InputCapsule; |
||||
import com.jme3.export.JmeExporter; |
||||
import com.jme3.export.JmeImporter; |
||||
import com.jme3.export.OutputCapsule; |
||||
import com.jme3.scene.Spatial; |
||||
import com.jme3.shader.VarType; |
||||
import java.io.IOException; |
||||
|
||||
/** |
||||
* <code>MatParamOverride</code> is a mechanism by which |
||||
* {@link MatParam material parameters} can be overridden on the scene graph. |
||||
* <p> |
||||
* A scene branch which has a <code>MatParamOverride</code> applied to it will |
||||
* cause all material parameters with the same name and type to have their value |
||||
* replaced with the value set on the <code>MatParamOverride</code>. If those |
||||
* parameters are mapped to a define, then the define will be overridden as well |
||||
* using the same rules as the ones used for regular material parameters. |
||||
* <p> |
||||
* <code>MatParamOverrides</code> are applied to a {@link Spatial} via the |
||||
* {@link Spatial#addMatParamOverride(com.jme3.material.MatParamOverride)} |
||||
* method. They are propagated to child <code>Spatials</code> via |
||||
* {@link Spatial#updateGeometricState()} similar to how lights are propagated. |
||||
* <p> |
||||
* Example:<br> |
||||
* <pre> |
||||
* {@code |
||||
* |
||||
* Geometry box = new Geometry("Box", new Box(1,1,1)); |
||||
* Material mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md"); |
||||
* mat.setColor("Color", ColorRGBA.Blue); |
||||
* box.setMaterial(mat); |
||||
* rootNode.attachChild(box); |
||||
* |
||||
* // ... later ...
|
||||
* MatParamOverride override = new MatParamOverride(Type.Vector4, "Color", ColorRGBA.Red); |
||||
* rootNode.addMatParamOverride(override); |
||||
* |
||||
* // After adding the override to the root node, the box becomes red.
|
||||
* } |
||||
* </pre> |
||||
* |
||||
* @author Kirill Vainer |
||||
* @see Spatial#addMatParamOverride(com.jme3.material.MatParamOverride) |
||||
* @see Spatial#getWorldMatParamOverrides() |
||||
*/ |
||||
public final class MatParamOverride extends MatParam { |
||||
|
||||
private boolean enabled = true; |
||||
|
||||
/** |
||||
* Serialization only. Do not use. |
||||
*/ |
||||
public MatParamOverride() { |
||||
super(); |
||||
} |
||||
|
||||
/** |
||||
* Create a new <code>MatParamOverride</code>. |
||||
* |
||||
* Overrides are created enabled by default. |
||||
* |
||||
* @param type The type of parameter. |
||||
* @param name The name of the parameter. |
||||
* @param value The value to set the material parameter to. |
||||
*/ |
||||
public MatParamOverride(VarType type, String name, Object value) { |
||||
super(type, name, value); |
||||
} |
||||
|
||||
@Override |
||||
public boolean equals(Object obj) { |
||||
return super.equals(obj) && this.enabled == ((MatParamOverride) obj).enabled; |
||||
} |
||||
|
||||
@Override |
||||
public int hashCode() { |
||||
int hash = super.hashCode(); |
||||
hash = 59 * hash + (enabled ? 1 : 0); |
||||
return hash; |
||||
} |
||||
|
||||
/** |
||||
* Determine if the <code>MatParamOverride</code> is enabled or disabled. |
||||
* |
||||
* @return true if enabled, false if disabled. |
||||
* @see #setEnabled(boolean) |
||||
*/ |
||||
public boolean isEnabled() { |
||||
return enabled; |
||||
} |
||||
|
||||
/** |
||||
* Enable or disable this <code>MatParamOverride</code>. |
||||
* |
||||
* When disabled, the override will continue to propagate through the scene |
||||
* graph like before, but it will have no effect on materials. Overrides are |
||||
* enabled by default. |
||||
* |
||||
* @param enabled Whether to enable or disable this override. |
||||
*/ |
||||
public void setEnabled(boolean enabled) { |
||||
this.enabled = enabled; |
||||
} |
||||
|
||||
@Override |
||||
public void write(JmeExporter ex) throws IOException { |
||||
super.write(ex); |
||||
OutputCapsule oc = ex.getCapsule(this); |
||||
oc.write(enabled, "enabled", true); |
||||
} |
||||
|
||||
@Override |
||||
public void read(JmeImporter im) throws IOException { |
||||
super.read(im); |
||||
InputCapsule ic = im.getCapsule(this); |
||||
enabled = ic.readBoolean("enabled", true); |
||||
} |
||||
} |
||||
@ -0,0 +1,97 @@ |
||||
/* |
||||
* Copyright (c) 2009-2015 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.material.logic; |
||||
|
||||
import com.jme3.asset.AssetManager; |
||||
import com.jme3.light.AmbientLight; |
||||
import com.jme3.light.Light; |
||||
import com.jme3.light.LightList; |
||||
import com.jme3.material.TechniqueDef; |
||||
import com.jme3.math.ColorRGBA; |
||||
import com.jme3.renderer.Caps; |
||||
import com.jme3.renderer.RenderManager; |
||||
import com.jme3.renderer.Renderer; |
||||
import com.jme3.scene.Geometry; |
||||
import com.jme3.scene.Mesh; |
||||
import com.jme3.scene.instancing.InstancedGeometry; |
||||
import com.jme3.shader.DefineList; |
||||
import com.jme3.shader.Shader; |
||||
import java.util.EnumSet; |
||||
|
||||
public class DefaultTechniqueDefLogic implements TechniqueDefLogic { |
||||
|
||||
protected final TechniqueDef techniqueDef; |
||||
|
||||
public DefaultTechniqueDefLogic(TechniqueDef techniqueDef) { |
||||
this.techniqueDef = techniqueDef; |
||||
} |
||||
|
||||
@Override |
||||
public Shader makeCurrent(AssetManager assetManager, RenderManager renderManager, |
||||
EnumSet<Caps> rendererCaps, LightList lights, DefineList defines) { |
||||
return techniqueDef.getShader(assetManager, rendererCaps, defines); |
||||
} |
||||
|
||||
public static void renderMeshFromGeometry(Renderer renderer, Geometry geom) { |
||||
Mesh mesh = geom.getMesh(); |
||||
int lodLevel = geom.getLodLevel(); |
||||
if (geom instanceof InstancedGeometry) { |
||||
InstancedGeometry instGeom = (InstancedGeometry) geom; |
||||
renderer.renderMesh(mesh, lodLevel, instGeom.getActualNumInstances(), |
||||
instGeom.getAllInstanceData()); |
||||
} else { |
||||
renderer.renderMesh(mesh, lodLevel, 1, null); |
||||
} |
||||
} |
||||
|
||||
protected static ColorRGBA getAmbientColor(LightList lightList, boolean removeLights, ColorRGBA ambientLightColor) { |
||||
ambientLightColor.set(0, 0, 0, 1); |
||||
for (int j = 0; j < lightList.size(); j++) { |
||||
Light l = lightList.get(j); |
||||
if (l instanceof AmbientLight) { |
||||
ambientLightColor.addLocal(l.getColor()); |
||||
if (removeLights) { |
||||
lightList.remove(l); |
||||
} |
||||
} |
||||
} |
||||
ambientLightColor.a = 1.0f; |
||||
return ambientLightColor; |
||||
} |
||||
|
||||
@Override |
||||
public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights) { |
||||
Renderer renderer = renderManager.getRenderer(); |
||||
renderer.setShader(shader); |
||||
renderMeshFromGeometry(renderer, geometry); |
||||
} |
||||
} |
||||
@ -0,0 +1,178 @@ |
||||
/* |
||||
* Copyright (c) 2009-2015 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.material.logic; |
||||
|
||||
import com.jme3.asset.AssetManager; |
||||
import com.jme3.light.AmbientLight; |
||||
import com.jme3.light.DirectionalLight; |
||||
import com.jme3.light.Light; |
||||
import com.jme3.light.LightList; |
||||
import com.jme3.light.PointLight; |
||||
import com.jme3.light.SpotLight; |
||||
import com.jme3.material.RenderState; |
||||
import com.jme3.material.TechniqueDef; |
||||
import com.jme3.math.ColorRGBA; |
||||
import com.jme3.math.FastMath; |
||||
import com.jme3.math.Quaternion; |
||||
import com.jme3.math.Vector3f; |
||||
import com.jme3.math.Vector4f; |
||||
import com.jme3.renderer.Caps; |
||||
import com.jme3.renderer.RenderManager; |
||||
import com.jme3.renderer.Renderer; |
||||
import com.jme3.scene.Geometry; |
||||
import com.jme3.shader.DefineList; |
||||
import com.jme3.shader.Shader; |
||||
import com.jme3.shader.Uniform; |
||||
import com.jme3.shader.VarType; |
||||
import com.jme3.util.TempVars; |
||||
import java.util.EnumSet; |
||||
|
||||
public final class MultiPassLightingLogic extends DefaultTechniqueDefLogic { |
||||
|
||||
private static final RenderState ADDITIVE_LIGHT = new RenderState(); |
||||
private static final Quaternion NULL_DIR_LIGHT = new Quaternion(0, -1, 0, -1); |
||||
|
||||
private final ColorRGBA ambientLightColor = new ColorRGBA(0, 0, 0, 1); |
||||
|
||||
static { |
||||
ADDITIVE_LIGHT.setBlendMode(RenderState.BlendMode.AlphaAdditive); |
||||
ADDITIVE_LIGHT.setDepthWrite(false); |
||||
} |
||||
|
||||
public MultiPassLightingLogic(TechniqueDef techniqueDef) { |
||||
super(techniqueDef); |
||||
} |
||||
|
||||
@Override |
||||
public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights) { |
||||
Renderer r = renderManager.getRenderer(); |
||||
Uniform lightDir = shader.getUniform("g_LightDirection"); |
||||
Uniform lightColor = shader.getUniform("g_LightColor"); |
||||
Uniform lightPos = shader.getUniform("g_LightPosition"); |
||||
Uniform ambientColor = shader.getUniform("g_AmbientLightColor"); |
||||
boolean isFirstLight = true; |
||||
boolean isSecondLight = false; |
||||
|
||||
getAmbientColor(lights, false, ambientLightColor); |
||||
|
||||
for (int i = 0; i < lights.size(); i++) { |
||||
Light l = lights.get(i); |
||||
if (l instanceof AmbientLight) { |
||||
continue; |
||||
} |
||||
|
||||
if (isFirstLight) { |
||||
// set ambient color for first light only
|
||||
ambientColor.setValue(VarType.Vector4, ambientLightColor); |
||||
isFirstLight = false; |
||||
isSecondLight = true; |
||||
} else if (isSecondLight) { |
||||
ambientColor.setValue(VarType.Vector4, ColorRGBA.Black); |
||||
// apply additive blending for 2nd and future lights
|
||||
r.applyRenderState(ADDITIVE_LIGHT); |
||||
isSecondLight = false; |
||||
} |
||||
|
||||
TempVars vars = TempVars.get(); |
||||
Quaternion tmpLightDirection = vars.quat1; |
||||
Quaternion tmpLightPosition = vars.quat2; |
||||
ColorRGBA tmpLightColor = vars.color; |
||||
Vector4f tmpVec = vars.vect4f1; |
||||
|
||||
ColorRGBA color = l.getColor(); |
||||
tmpLightColor.set(color); |
||||
tmpLightColor.a = l.getType().getId(); |
||||
lightColor.setValue(VarType.Vector4, tmpLightColor); |
||||
|
||||
switch (l.getType()) { |
||||
case Directional: |
||||
DirectionalLight dl = (DirectionalLight) l; |
||||
Vector3f dir = dl.getDirection(); |
||||
//FIXME : there is an inconstency here due to backward
|
||||
//compatibility of the lighting shader.
|
||||
//The directional light direction is passed in the
|
||||
//LightPosition uniform. The lighting shader needs to be
|
||||
//reworked though in order to fix this.
|
||||
tmpLightPosition.set(dir.getX(), dir.getY(), dir.getZ(), -1); |
||||
lightPos.setValue(VarType.Vector4, tmpLightPosition); |
||||
tmpLightDirection.set(0, 0, 0, 0); |
||||
lightDir.setValue(VarType.Vector4, tmpLightDirection); |
||||
break; |
||||
case Point: |
||||
PointLight pl = (PointLight) l; |
||||
Vector3f pos = pl.getPosition(); |
||||
float invRadius = pl.getInvRadius(); |
||||
|
||||
tmpLightPosition.set(pos.getX(), pos.getY(), pos.getZ(), invRadius); |
||||
lightPos.setValue(VarType.Vector4, tmpLightPosition); |
||||
tmpLightDirection.set(0, 0, 0, 0); |
||||
lightDir.setValue(VarType.Vector4, tmpLightDirection); |
||||
break; |
||||
case Spot: |
||||
SpotLight sl = (SpotLight) l; |
||||
Vector3f pos2 = sl.getPosition(); |
||||
Vector3f dir2 = sl.getDirection(); |
||||
float invRange = sl.getInvSpotRange(); |
||||
float spotAngleCos = sl.getPackedAngleCos(); |
||||
|
||||
tmpLightPosition.set(pos2.getX(), pos2.getY(), pos2.getZ(), invRange); |
||||
lightPos.setValue(VarType.Vector4, tmpLightPosition); |
||||
|
||||
//We transform the spot direction in view space here to save 5 varying later in the lighting shader
|
||||
//one vec4 less and a vec4 that becomes a vec3
|
||||
//the downside is that spotAngleCos decoding happens now in the frag shader.
|
||||
tmpVec.set(dir2.getX(), dir2.getY(), dir2.getZ(), 0); |
||||
renderManager.getCurrentCamera().getViewMatrix().mult(tmpVec, tmpVec); |
||||
tmpLightDirection.set(tmpVec.getX(), tmpVec.getY(), tmpVec.getZ(), spotAngleCos); |
||||
|
||||
lightDir.setValue(VarType.Vector4, tmpLightDirection); |
||||
|
||||
break; |
||||
default: |
||||
throw new UnsupportedOperationException("Unknown type of light: " + l.getType()); |
||||
} |
||||
vars.release(); |
||||
r.setShader(shader); |
||||
renderMeshFromGeometry(r, geometry); |
||||
} |
||||
|
||||
if (isFirstLight) { |
||||
// Either there are no lights at all, or only ambient lights.
|
||||
// Render a dummy "normal light" so we can see the ambient color.
|
||||
ambientColor.setValue(VarType.Vector4, getAmbientColor(lights, false, ambientLightColor)); |
||||
lightColor.setValue(VarType.Vector4, ColorRGBA.BlackNoAlpha); |
||||
lightPos.setValue(VarType.Vector4, NULL_DIR_LIGHT); |
||||
r.setShader(shader); |
||||
renderMeshFromGeometry(r, geometry); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,218 @@ |
||||
/* |
||||
* Copyright (c) 2009-2015 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.material.logic; |
||||
|
||||
import com.jme3.asset.AssetManager; |
||||
import com.jme3.light.DirectionalLight; |
||||
import com.jme3.light.Light; |
||||
import com.jme3.light.LightList; |
||||
import com.jme3.light.PointLight; |
||||
import com.jme3.light.SpotLight; |
||||
import com.jme3.material.RenderState; |
||||
import com.jme3.material.RenderState.BlendMode; |
||||
import com.jme3.material.TechniqueDef; |
||||
import com.jme3.math.ColorRGBA; |
||||
import com.jme3.math.Vector3f; |
||||
import com.jme3.math.Vector4f; |
||||
import com.jme3.renderer.Caps; |
||||
import com.jme3.renderer.RenderManager; |
||||
import com.jme3.renderer.Renderer; |
||||
import com.jme3.scene.Geometry; |
||||
import com.jme3.shader.DefineList; |
||||
import com.jme3.shader.Shader; |
||||
import com.jme3.shader.Uniform; |
||||
import com.jme3.shader.VarType; |
||||
import com.jme3.util.TempVars; |
||||
import java.util.EnumSet; |
||||
|
||||
public final class SinglePassLightingLogic extends DefaultTechniqueDefLogic { |
||||
|
||||
private static final String DEFINE_SINGLE_PASS_LIGHTING = "SINGLE_PASS_LIGHTING"; |
||||
private static final String DEFINE_NB_LIGHTS = "NB_LIGHTS"; |
||||
private static final RenderState ADDITIVE_LIGHT = new RenderState(); |
||||
|
||||
private final ColorRGBA ambientLightColor = new ColorRGBA(0, 0, 0, 1); |
||||
|
||||
static { |
||||
ADDITIVE_LIGHT.setBlendMode(BlendMode.AlphaAdditive); |
||||
ADDITIVE_LIGHT.setDepthWrite(false); |
||||
} |
||||
|
||||
private final int singlePassLightingDefineId; |
||||
private final int nbLightsDefineId; |
||||
|
||||
public SinglePassLightingLogic(TechniqueDef techniqueDef) { |
||||
super(techniqueDef); |
||||
singlePassLightingDefineId = techniqueDef.addShaderUnmappedDefine(DEFINE_SINGLE_PASS_LIGHTING, VarType.Boolean); |
||||
nbLightsDefineId = techniqueDef.addShaderUnmappedDefine(DEFINE_NB_LIGHTS, VarType.Int); |
||||
} |
||||
|
||||
@Override |
||||
public Shader makeCurrent(AssetManager assetManager, RenderManager renderManager, |
||||
EnumSet<Caps> rendererCaps, LightList lights, DefineList defines) { |
||||
defines.set(nbLightsDefineId, renderManager.getSinglePassLightBatchSize() * 3); |
||||
defines.set(singlePassLightingDefineId, true); |
||||
return super.makeCurrent(assetManager, renderManager, rendererCaps, lights, defines); |
||||
} |
||||
|
||||
/** |
||||
* Uploads the lights in the light list as two uniform arrays.<br/><br/> * |
||||
* <p> |
||||
* <code>uniform vec4 g_LightColor[numLights];</code><br/> //
|
||||
* g_LightColor.rgb is the diffuse/specular color of the light.<br/> //
|
||||
* g_Lightcolor.a is the type of light, 0 = Directional, 1 = Point, <br/> //
|
||||
* 2 = Spot. <br/> <br/> |
||||
* <code>uniform vec4 g_LightPosition[numLights];</code><br/> //
|
||||
* g_LightPosition.xyz is the position of the light (for point lights)<br/> |
||||
* // or the direction of the light (for directional lights).<br/> //
|
||||
* g_LightPosition.w is the inverse radius (1/r) of the light (for |
||||
* attenuation) <br/> </p> |
||||
*/ |
||||
protected int updateLightListUniforms(Shader shader, Geometry g, LightList lightList, int numLights, RenderManager rm, int startIndex) { |
||||
if (numLights == 0) { // this shader does not do lighting, ignore.
|
||||
return 0; |
||||
} |
||||
|
||||
Uniform lightData = shader.getUniform("g_LightData"); |
||||
lightData.setVector4Length(numLights * 3);//8 lights * max 3
|
||||
Uniform ambientColor = shader.getUniform("g_AmbientLightColor"); |
||||
|
||||
|
||||
if (startIndex != 0) { |
||||
// apply additive blending for 2nd and future passes
|
||||
rm.getRenderer().applyRenderState(ADDITIVE_LIGHT); |
||||
ambientColor.setValue(VarType.Vector4, ColorRGBA.Black); |
||||
} else { |
||||
ambientColor.setValue(VarType.Vector4, getAmbientColor(lightList, true, ambientLightColor)); |
||||
} |
||||
|
||||
int lightDataIndex = 0; |
||||
TempVars vars = TempVars.get(); |
||||
Vector4f tmpVec = vars.vect4f1; |
||||
int curIndex; |
||||
int endIndex = numLights + startIndex; |
||||
for (curIndex = startIndex; curIndex < endIndex && curIndex < lightList.size(); curIndex++) { |
||||
|
||||
Light l = lightList.get(curIndex); |
||||
if (l.getType() == Light.Type.Ambient) { |
||||
endIndex++; |
||||
continue; |
||||
} |
||||
ColorRGBA color = l.getColor(); |
||||
//Color
|
||||
lightData.setVector4InArray(color.getRed(), |
||||
color.getGreen(), |
||||
color.getBlue(), |
||||
l.getType().getId(), |
||||
lightDataIndex); |
||||
lightDataIndex++; |
||||
|
||||
switch (l.getType()) { |
||||
case Directional: |
||||
DirectionalLight dl = (DirectionalLight) l; |
||||
Vector3f dir = dl.getDirection(); |
||||
//Data directly sent in view space to avoid a matrix mult for each pixel
|
||||
tmpVec.set(dir.getX(), dir.getY(), dir.getZ(), 0.0f); |
||||
rm.getCurrentCamera().getViewMatrix().mult(tmpVec, tmpVec); |
||||
// tmpVec.divideLocal(tmpVec.w);
|
||||
// tmpVec.normalizeLocal();
|
||||
lightData.setVector4InArray(tmpVec.getX(), tmpVec.getY(), tmpVec.getZ(), -1, lightDataIndex); |
||||
lightDataIndex++; |
||||
//PADDING
|
||||
lightData.setVector4InArray(0, 0, 0, 0, lightDataIndex); |
||||
lightDataIndex++; |
||||
break; |
||||
case Point: |
||||
PointLight pl = (PointLight) l; |
||||
Vector3f pos = pl.getPosition(); |
||||
float invRadius = pl.getInvRadius(); |
||||
tmpVec.set(pos.getX(), pos.getY(), pos.getZ(), 1.0f); |
||||
rm.getCurrentCamera().getViewMatrix().mult(tmpVec, tmpVec); |
||||
//tmpVec.divideLocal(tmpVec.w);
|
||||
lightData.setVector4InArray(tmpVec.getX(), tmpVec.getY(), tmpVec.getZ(), invRadius, lightDataIndex); |
||||
lightDataIndex++; |
||||
//PADDING
|
||||
lightData.setVector4InArray(0, 0, 0, 0, lightDataIndex); |
||||
lightDataIndex++; |
||||
break; |
||||
case Spot: |
||||
SpotLight sl = (SpotLight) l; |
||||
Vector3f pos2 = sl.getPosition(); |
||||
Vector3f dir2 = sl.getDirection(); |
||||
float invRange = sl.getInvSpotRange(); |
||||
float spotAngleCos = sl.getPackedAngleCos(); |
||||
tmpVec.set(pos2.getX(), pos2.getY(), pos2.getZ(), 1.0f); |
||||
rm.getCurrentCamera().getViewMatrix().mult(tmpVec, tmpVec); |
||||
// tmpVec.divideLocal(tmpVec.w);
|
||||
lightData.setVector4InArray(tmpVec.getX(), tmpVec.getY(), tmpVec.getZ(), invRange, lightDataIndex); |
||||
lightDataIndex++; |
||||
|
||||
//We transform the spot direction in view space here to save 5 varying later in the lighting shader
|
||||
//one vec4 less and a vec4 that becomes a vec3
|
||||
//the downside is that spotAngleCos decoding happens now in the frag shader.
|
||||
tmpVec.set(dir2.getX(), dir2.getY(), dir2.getZ(), 0.0f); |
||||
rm.getCurrentCamera().getViewMatrix().mult(tmpVec, tmpVec); |
||||
tmpVec.normalizeLocal(); |
||||
lightData.setVector4InArray(tmpVec.getX(), tmpVec.getY(), tmpVec.getZ(), spotAngleCos, lightDataIndex); |
||||
lightDataIndex++; |
||||
break; |
||||
default: |
||||
throw new UnsupportedOperationException("Unknown type of light: " + l.getType()); |
||||
} |
||||
} |
||||
vars.release(); |
||||
//Padding of unsued buffer space
|
||||
while(lightDataIndex < numLights * 3) { |
||||
lightData.setVector4InArray(0f, 0f, 0f, 0f, lightDataIndex); |
||||
lightDataIndex++; |
||||
} |
||||
return curIndex; |
||||
} |
||||
|
||||
@Override |
||||
public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights) { |
||||
int nbRenderedLights = 0; |
||||
Renderer renderer = renderManager.getRenderer(); |
||||
int batchSize = renderManager.getSinglePassLightBatchSize(); |
||||
if (lights.size() == 0) { |
||||
updateLightListUniforms(shader, geometry, lights, batchSize, renderManager, 0); |
||||
renderer.setShader(shader); |
||||
renderMeshFromGeometry(renderer, geometry); |
||||
} else { |
||||
while (nbRenderedLights < lights.size()) { |
||||
nbRenderedLights = updateLightListUniforms(shader, geometry, lights, batchSize, renderManager, nbRenderedLights); |
||||
renderer.setShader(shader); |
||||
renderMeshFromGeometry(renderer, geometry); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,157 @@ |
||||
/* |
||||
* Copyright (c) 2009-2015 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.material.logic; |
||||
|
||||
import com.jme3.asset.AssetManager; |
||||
import com.jme3.light.DirectionalLight; |
||||
import com.jme3.light.Light; |
||||
import com.jme3.light.Light.Type; |
||||
import com.jme3.light.LightList; |
||||
import com.jme3.light.PointLight; |
||||
import com.jme3.light.SpotLight; |
||||
import com.jme3.material.TechniqueDef; |
||||
import com.jme3.math.ColorRGBA; |
||||
import com.jme3.math.Vector3f; |
||||
import com.jme3.renderer.Caps; |
||||
import com.jme3.renderer.RenderManager; |
||||
import com.jme3.renderer.Renderer; |
||||
import com.jme3.scene.Geometry; |
||||
import com.jme3.shader.DefineList; |
||||
import com.jme3.shader.Shader; |
||||
import com.jme3.shader.Uniform; |
||||
import com.jme3.shader.VarType; |
||||
import java.util.ArrayList; |
||||
import java.util.EnumSet; |
||||
|
||||
/** |
||||
* Rendering logic for static pass. |
||||
* |
||||
* @author Kirill Vainer |
||||
*/ |
||||
public final class StaticPassLightingLogic extends DefaultTechniqueDefLogic { |
||||
|
||||
private static final String DEFINE_NUM_DIR_LIGHTS = "NUM_DIR_LIGHTS"; |
||||
private static final String DEFINE_NUM_POINT_LIGHTS = "NUM_POINT_LIGHTS"; |
||||
private static final String DEFINE_NUM_SPOT_LIGHTS = "NUM_SPOT_LIGHTS"; |
||||
|
||||
private final int numDirLightsDefineId; |
||||
private final int numPointLightsDefineId; |
||||
private final int numSpotLightsDefineId; |
||||
|
||||
private final ArrayList<DirectionalLight> tempDirLights = new ArrayList<DirectionalLight>(); |
||||
private final ArrayList<PointLight> tempPointLights = new ArrayList<PointLight>(); |
||||
private final ArrayList<SpotLight> tempSpotLights = new ArrayList<SpotLight>(); |
||||
|
||||
private final ColorRGBA ambientLightColor = new ColorRGBA(0, 0, 0, 1); |
||||
|
||||
public StaticPassLightingLogic(TechniqueDef techniqueDef) { |
||||
super(techniqueDef); |
||||
|
||||
numDirLightsDefineId = techniqueDef.addShaderUnmappedDefine(DEFINE_NUM_DIR_LIGHTS, VarType.Int); |
||||
numPointLightsDefineId = techniqueDef.addShaderUnmappedDefine(DEFINE_NUM_POINT_LIGHTS, VarType.Int); |
||||
numSpotLightsDefineId = techniqueDef.addShaderUnmappedDefine(DEFINE_NUM_SPOT_LIGHTS, VarType.Int); |
||||
} |
||||
|
||||
@Override |
||||
public Shader makeCurrent(AssetManager assetManager, RenderManager renderManager, |
||||
EnumSet<Caps> rendererCaps, LightList lights, DefineList defines) { |
||||
|
||||
// TODO: if it ever changes that render isn't called
|
||||
// right away with the same geometry after makeCurrent, it would be
|
||||
// a problem.
|
||||
// Do a radix sort.
|
||||
tempDirLights.clear(); |
||||
tempPointLights.clear(); |
||||
tempSpotLights.clear(); |
||||
for (Light light : lights) { |
||||
switch (light.getType()) { |
||||
case Directional: |
||||
tempDirLights.add((DirectionalLight) light); |
||||
break; |
||||
case Point: |
||||
tempPointLights.add((PointLight) light); |
||||
break; |
||||
case Spot: |
||||
tempSpotLights.add((SpotLight) light); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
defines.set(numDirLightsDefineId, tempDirLights.size()); |
||||
defines.set(numPointLightsDefineId, tempPointLights.size()); |
||||
defines.set(numSpotLightsDefineId, tempSpotLights.size()); |
||||
|
||||
return techniqueDef.getShader(assetManager, rendererCaps, defines); |
||||
} |
||||
|
||||
private void updateLightListUniforms(Shader shader, LightList lights) { |
||||
Uniform ambientColor = shader.getUniform("g_AmbientLightColor"); |
||||
ambientColor.setValue(VarType.Vector4, getAmbientColor(lights, true, ambientLightColor)); |
||||
|
||||
Uniform lightData = shader.getUniform("g_LightData"); |
||||
|
||||
int index = 0; |
||||
for (DirectionalLight light : tempDirLights) { |
||||
ColorRGBA color = light.getColor(); |
||||
Vector3f dir = light.getDirection(); |
||||
lightData.setVector4InArray(color.r, color.g, color.b, 1f, index++); |
||||
lightData.setVector4InArray(dir.x, dir.y, dir.z, 1f, index++); |
||||
} |
||||
|
||||
for (PointLight light : tempPointLights) { |
||||
ColorRGBA color = light.getColor(); |
||||
Vector3f pos = light.getPosition(); |
||||
lightData.setVector4InArray(color.r, color.g, color.b, 1f, index++); |
||||
lightData.setVector4InArray(pos.x, pos.y, pos.z, 1f, index++); |
||||
} |
||||
|
||||
for (SpotLight light : tempSpotLights) { |
||||
ColorRGBA color = light.getColor(); |
||||
Vector3f pos = light.getPosition(); |
||||
Vector3f dir = light.getDirection(); |
||||
float invRange = light.getInvSpotRange(); |
||||
float spotAngleCos = light.getPackedAngleCos(); |
||||
lightData.setVector4InArray(color.r, color.g, color.b, 1f, index++); |
||||
lightData.setVector4InArray(pos.x, pos.y, pos.z, invRange, index++); |
||||
lightData.setVector4InArray(dir.x, dir.y, dir.z, spotAngleCos, index++); |
||||
} |
||||
} |
||||
|
||||
@Override |
||||
public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights) { |
||||
Renderer renderer = renderManager.getRenderer(); |
||||
updateLightListUniforms(shader, lights); |
||||
renderer.setShader(shader); |
||||
renderMeshFromGeometry(renderer, geometry); |
||||
} |
||||
|
||||
} |
||||
@ -0,0 +1,97 @@ |
||||
/* |
||||
* Copyright (c) 2009-2015 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.material.logic; |
||||
|
||||
import com.jme3.asset.AssetManager; |
||||
import com.jme3.light.LightList; |
||||
import com.jme3.material.TechniqueDef.LightMode; |
||||
import com.jme3.renderer.Caps; |
||||
import com.jme3.renderer.RenderManager; |
||||
import com.jme3.scene.Geometry; |
||||
import com.jme3.shader.DefineList; |
||||
import com.jme3.shader.Shader; |
||||
import com.jme3.shader.Uniform; |
||||
import com.jme3.shader.UniformBinding; |
||||
import com.jme3.texture.Texture; |
||||
import java.util.EnumSet; |
||||
|
||||
/** |
||||
* <code>TechniqueDefLogic</code> is used to customize how |
||||
* a material should be rendered. |
||||
* |
||||
* Typically used to implement {@link LightMode lighting modes}. |
||||
* Implementations can register |
||||
* {@link TechniqueDef#addShaderUnmappedDefine(java.lang.String) unmapped defines} |
||||
* in their constructor and then later set them based on the geometry |
||||
* or light environment being rendered. |
||||
* |
||||
* @author Kirill Vainer |
||||
*/ |
||||
public interface TechniqueDefLogic { |
||||
|
||||
/** |
||||
* Determine the shader to use for the given geometry / material combination. |
||||
* |
||||
* @param assetManager The asset manager to use for loading shader source code, |
||||
* shader nodes, and and lookup textures. |
||||
* @param renderManager The render manager for which rendering is to be performed. |
||||
* @param rendererCaps Renderer capabilities. The returned shader must |
||||
* support these capabilities. |
||||
* @param lights The lights with which the geometry shall be rendered. This |
||||
* list must not include culled lights. |
||||
* @param defines The define list used by the technique, any |
||||
* {@link TechniqueDef#addShaderUnmappedDefine(java.lang.String) unmapped defines} |
||||
* should be set here to change shader behavior. |
||||
* |
||||
* @return The shader to use for rendering. |
||||
*/ |
||||
public Shader makeCurrent(AssetManager assetManager, RenderManager renderManager, |
||||
EnumSet<Caps> rendererCaps, LightList lights, DefineList defines); |
||||
|
||||
/** |
||||
* Requests that the <code>TechniqueDefLogic</code> renders the given geometry. |
||||
* |
||||
* Fixed material functionality such as {@link RenderState}, |
||||
* {@link MatParam material parameters}, and |
||||
* {@link UniformBinding uniform bindings} |
||||
* have already been applied by the material, however, |
||||
* {@link RenderState}, {@link Uniform uniforms}, {@link Texture textures}, |
||||
* can still be overriden. |
||||
* |
||||
* @param renderManager The render manager to perform the rendering against. |
||||
* * @param shader The shader that was selected by this logic in |
||||
* {@link #makeCurrent(com.jme3.asset.AssetManager, com.jme3.renderer.RenderManager, java.util.EnumSet, com.jme3.shader.DefineList)}. |
||||
* @param geometry The geometry to render |
||||
* @param lights Lights which influence the geometry. |
||||
*/ |
||||
public void render(RenderManager renderManager, Shader shader, Geometry geometry, LightList lights); |
||||
} |
||||
@ -1,286 +1,179 @@ |
||||
/* |
||||
* 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.shader; |
||||
|
||||
import com.jme3.export.*; |
||||
import com.jme3.material.MatParam; |
||||
import com.jme3.material.TechniqueDef; |
||||
import com.jme3.util.ListMap; |
||||
|
||||
import java.io.IOException; |
||||
import java.util.Map; |
||||
import java.util.TreeMap; |
||||
|
||||
public final class DefineList implements Savable, Cloneable { |
||||
|
||||
private static final String ONE = "1"; |
||||
|
||||
private TreeMap<String, String> defines = new TreeMap<String, String>(); |
||||
private String compiled = null; |
||||
private int cachedHashCode = 0; |
||||
|
||||
public void write(JmeExporter ex) throws IOException{ |
||||
OutputCapsule oc = ex.getCapsule(this); |
||||
|
||||
String[] keys = new String[defines.size()]; |
||||
String[] vals = new String[defines.size()]; |
||||
|
||||
int i = 0; |
||||
for (Map.Entry<String, String> define : defines.entrySet()){ |
||||
keys[i] = define.getKey(); |
||||
vals[i] = define.getValue(); |
||||
i++; |
||||
} |
||||
|
||||
oc.write(keys, "keys", null); |
||||
oc.write(vals, "vals", null); |
||||
} |
||||
|
||||
public void read(JmeImporter im) throws IOException{ |
||||
InputCapsule ic = im.getCapsule(this); |
||||
|
||||
String[] keys = ic.readStringArray("keys", null); |
||||
String[] vals = ic.readStringArray("vals", null); |
||||
for (int i = 0; i < keys.length; i++){ |
||||
defines.put(keys[i], vals[i]); |
||||
} |
||||
} |
||||
|
||||
public void clear() { |
||||
defines.clear(); |
||||
compiled = ""; |
||||
cachedHashCode = 0; |
||||
} |
||||
|
||||
public String get(String key){ |
||||
return defines.get(key); |
||||
} |
||||
|
||||
@Override |
||||
public DefineList clone() { |
||||
try { |
||||
DefineList clone = (DefineList) super.clone(); |
||||
clone.cachedHashCode = 0; |
||||
clone.compiled = null; |
||||
clone.defines = (TreeMap<String, String>) defines.clone(); |
||||
return clone; |
||||
} catch (CloneNotSupportedException ex) { |
||||
throw new AssertionError(); |
||||
} |
||||
} |
||||
|
||||
public boolean set(String key, VarType type, Object val){ |
||||
if (val == null){ |
||||
defines.remove(key); |
||||
compiled = null; |
||||
cachedHashCode = 0; |
||||
return true; |
||||
} |
||||
|
||||
switch (type){ |
||||
case Boolean: |
||||
if (((Boolean) val).booleanValue()) { |
||||
// same literal, != will work
|
||||
if (defines.put(key, ONE) != ONE) { |
||||
compiled = null; |
||||
cachedHashCode = 0; |
||||
return true; |
||||
} |
||||
} else if (defines.containsKey(key)) { |
||||
defines.remove(key); |
||||
compiled = null; |
||||
cachedHashCode = 0; |
||||
return true; |
||||
} |
||||
|
||||
break; |
||||
case Float: |
||||
case Int: |
||||
String newValue = val.toString(); |
||||
String original = defines.put(key, newValue); |
||||
if (!val.equals(original)) { |
||||
compiled = null; |
||||
cachedHashCode = 0; |
||||
return true; |
||||
} |
||||
break; |
||||
default: |
||||
// same literal, != will work
|
||||
if (defines.put(key, ONE) != ONE) { |
||||
compiled = null; |
||||
cachedHashCode = 0; |
||||
return true; |
||||
} |
||||
break; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
|
||||
public boolean remove(String key){ |
||||
if (defines.remove(key) != null) { |
||||
compiled = null; |
||||
cachedHashCode = 0; |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
public void addFrom(DefineList other){ |
||||
if (other == null) { |
||||
return; |
||||
} |
||||
compiled = null; |
||||
cachedHashCode = 0; |
||||
defines.putAll(other.defines); |
||||
} |
||||
|
||||
public String getCompiled(){ |
||||
if (compiled == null){ |
||||
StringBuilder sb = new StringBuilder(); |
||||
for (Map.Entry<String, String> entry : defines.entrySet()){ |
||||
sb.append("#define ").append(entry.getKey()).append(" "); |
||||
sb.append(entry.getValue()).append('\n'); |
||||
} |
||||
compiled = sb.toString(); |
||||
} |
||||
return compiled; |
||||
} |
||||
|
||||
@Override |
||||
public boolean equals(Object obj) { |
||||
final DefineList other = (DefineList) obj; |
||||
return defines.equals(other.defines); |
||||
} |
||||
|
||||
/** |
||||
* Update defines if the define list changed based on material parameters. |
||||
* @param params |
||||
* @param def |
||||
* @return true if defines was updated |
||||
*/ |
||||
public boolean update(ListMap params, TechniqueDef def){ |
||||
if(equalsParams(params, def)){ |
||||
return false; |
||||
} |
||||
// Defines were changed, update define list
|
||||
clear(); |
||||
for(int i=0;i<params.size();i++) { |
||||
MatParam param = (MatParam)params.getValue(i); |
||||
String defineName = def.getShaderParamDefine(param.getName()); |
||||
if (defineName != null) { |
||||
set(defineName, param.getVarType(), param.getValue()); |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
private boolean equalsParams(ListMap params, TechniqueDef def) { |
||||
|
||||
int size = 0; |
||||
|
||||
for(int i = 0; i < params.size() ; i++ ) { |
||||
MatParam param = (MatParam)params.getValue(i); |
||||
String key = def.getShaderParamDefine(param.getName()); |
||||
if (key != null) { |
||||
Object val = param.getValue(); |
||||
if (val != null) { |
||||
|
||||
switch (param.getVarType()) { |
||||
case Boolean: { |
||||
String current = defines.get(key); |
||||
if (((Boolean) val).booleanValue()) { |
||||
if (current == null || current != ONE) { |
||||
return false; |
||||
} |
||||
size++; |
||||
} else { |
||||
if (current != null) { |
||||
return false; |
||||
} |
||||
} |
||||
} |
||||
break; |
||||
case Float: |
||||
case Int: { |
||||
String newValue = val.toString(); |
||||
String current = defines.get(key); |
||||
if (!newValue.equals(current)) { |
||||
return false; |
||||
} |
||||
size++; |
||||
} |
||||
break; |
||||
default: { |
||||
if (!defines.containsKey(key)) { |
||||
return false; |
||||
} |
||||
size++; |
||||
} |
||||
break; |
||||
} |
||||
|
||||
} |
||||
|
||||
} |
||||
} |
||||
|
||||
if (size != defines.size()) { |
||||
return false; |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
@Override |
||||
public int hashCode() { |
||||
if (cachedHashCode == 0) { |
||||
cachedHashCode = defines.hashCode(); |
||||
} |
||||
return cachedHashCode; |
||||
} |
||||
|
||||
@Override |
||||
public String toString(){ |
||||
StringBuilder sb = new StringBuilder(); |
||||
int i = 0; |
||||
for (Map.Entry<String, String> entry : defines.entrySet()) { |
||||
sb.append(entry.getKey()).append("=").append(entry.getValue()); |
||||
if (i != defines.size() - 1) { |
||||
sb.append(", "); |
||||
} |
||||
i++; |
||||
} |
||||
return sb.toString(); |
||||
} |
||||
|
||||
} |
||||
/* |
||||
* Copyright (c) 2009-2015 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.shader; |
||||
|
||||
import java.util.Arrays; |
||||
import java.util.List; |
||||
|
||||
/** |
||||
* The new define list. |
||||
* |
||||
* @author Kirill Vainer |
||||
*/ |
||||
public final class DefineList { |
||||
|
||||
public static final int MAX_DEFINES = 64; |
||||
|
||||
private long hash; |
||||
private final int[] vals; |
||||
|
||||
public DefineList(int numValues) { |
||||
if (numValues < 0 || numValues > MAX_DEFINES) { |
||||
throw new IllegalArgumentException("numValues must be between 0 and 64"); |
||||
} |
||||
vals = new int[numValues]; |
||||
} |
||||
|
||||
private DefineList(DefineList original) { |
||||
this.hash = original.hash; |
||||
this.vals = new int[original.vals.length]; |
||||
System.arraycopy(original.vals, 0, vals, 0, vals.length); |
||||
} |
||||
|
||||
public void set(int id, int val) { |
||||
assert 0 <= id && id < 64; |
||||
if (val != 0) { |
||||
hash |= (1L << id); |
||||
} else { |
||||
hash &= ~(1L << id); |
||||
} |
||||
vals[id] = val; |
||||
} |
||||
|
||||
public void set(int id, float val) { |
||||
set(id, Float.floatToIntBits(val)); |
||||
} |
||||
|
||||
public void set(int id, boolean val) { |
||||
set(id, val ? 1 : 0); |
||||
} |
||||
|
||||
public void set(int id, VarType type, Object value) { |
||||
if (value == null) { |
||||
set(id, 0); |
||||
return; |
||||
} |
||||
|
||||
switch (type) { |
||||
case Int: |
||||
set(id, (Integer) value); |
||||
break; |
||||
case Float: |
||||
set(id, (Float) value); |
||||
break; |
||||
case Boolean: |
||||
set(id, ((Boolean) value)); |
||||
break; |
||||
default: |
||||
set(id, 1); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
public void setAll(DefineList other) { |
||||
for (int i = 0; i < other.vals.length; i++) { |
||||
if (other.vals[i] != 0) { |
||||
vals[i] = other.vals[i]; |
||||
} |
||||
} |
||||
} |
||||
|
||||
public void clear() { |
||||
hash = 0; |
||||
Arrays.fill(vals, 0); |
||||
} |
||||
|
||||
public boolean getBoolean(int id) { |
||||
return vals[id] != 0; |
||||
} |
||||
|
||||
public float getFloat(int id) { |
||||
return Float.intBitsToFloat(vals[id]); |
||||
} |
||||
|
||||
public int getInt(int id) { |
||||
return vals[id]; |
||||
} |
||||
|
||||
@Override |
||||
public int hashCode() { |
||||
return (int)((hash >> 32) ^ hash); |
||||
} |
||||
|
||||
@Override |
||||
public boolean equals(Object other) { |
||||
DefineList o = (DefineList) other; |
||||
if (hash == o.hash) { |
||||
for (int i = 0; i < vals.length; i++) { |
||||
if (vals[i] != o.vals[i]) return false; |
||||
} |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
public DefineList deepClone() { |
||||
return new DefineList(this); |
||||
} |
||||
|
||||
public void generateSource(StringBuilder sb, List<String> defineNames, List<VarType> defineTypes) { |
||||
for (int i = 0; i < vals.length; i++) { |
||||
if (vals[i] != 0) { |
||||
String defineName = defineNames.get(i); |
||||
|
||||
sb.append("#define "); |
||||
sb.append(defineName); |
||||
sb.append(" "); |
||||
|
||||
if (defineTypes != null && defineTypes.get(i) == VarType.Float) { |
||||
float val = Float.intBitsToFloat(vals[i]); |
||||
if (Float.isInfinite(val) || Float.isNaN(val)) { |
||||
throw new IllegalArgumentException( |
||||
"GLSL does not support NaN " |
||||
+ "or Infinite float literals"); |
||||
} |
||||
sb.append(val); |
||||
} else { |
||||
sb.append(vals[i]); |
||||
} |
||||
|
||||
sb.append("\n"); |
||||
} |
||||
} |
||||
} |
||||
|
||||
public String generateSource(List<String> defineNames, List<VarType> defineTypes) { |
||||
StringBuilder sb = new StringBuilder(); |
||||
generateSource(sb, defineNames, defineTypes); |
||||
return sb.toString(); |
||||
} |
||||
} |
||||
@ -1,201 +0,0 @@ |
||||
/* |
||||
* 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.shader; |
||||
|
||||
import com.jme3.asset.AssetKey; |
||||
import com.jme3.export.InputCapsule; |
||||
import com.jme3.export.JmeExporter; |
||||
import com.jme3.export.JmeImporter; |
||||
import com.jme3.export.OutputCapsule; |
||||
import java.io.IOException; |
||||
import java.util.EnumMap; |
||||
import java.util.Set; |
||||
|
||||
public class ShaderKey extends AssetKey<Shader> { |
||||
|
||||
protected EnumMap<Shader.ShaderType,String> shaderLanguage; |
||||
protected EnumMap<Shader.ShaderType,String> shaderName; |
||||
protected DefineList defines; |
||||
protected int cachedHashedCode = 0; |
||||
protected boolean usesShaderNodes = false; |
||||
|
||||
public ShaderKey(){ |
||||
shaderLanguage=new EnumMap<Shader.ShaderType, String>(Shader.ShaderType.class); |
||||
shaderName=new EnumMap<Shader.ShaderType, String>(Shader.ShaderType.class); |
||||
} |
||||
|
||||
public ShaderKey(DefineList defines, EnumMap<Shader.ShaderType,String> shaderLanguage,EnumMap<Shader.ShaderType,String> shaderName){ |
||||
super(""); |
||||
this.name = reducePath(getShaderName(Shader.ShaderType.Vertex)); |
||||
this.shaderLanguage=new EnumMap<Shader.ShaderType, String>(Shader.ShaderType.class); |
||||
this.shaderName=new EnumMap<Shader.ShaderType, String>(Shader.ShaderType.class); |
||||
this.defines = defines; |
||||
for (Shader.ShaderType shaderType : shaderName.keySet()) { |
||||
this.shaderName.put(shaderType,shaderName.get(shaderType)); |
||||
this.shaderLanguage.put(shaderType,shaderLanguage.get(shaderType)); |
||||
} |
||||
} |
||||
|
||||
@Override |
||||
public ShaderKey clone() { |
||||
ShaderKey clone = (ShaderKey) super.clone(); |
||||
clone.cachedHashedCode = 0; |
||||
clone.defines = defines.clone(); |
||||
return clone; |
||||
} |
||||
|
||||
@Override |
||||
public String toString(){ |
||||
//todo:
|
||||
return "V="+name+";"; |
||||
} |
||||
|
||||
private final String getShaderName(Shader.ShaderType type) { |
||||
if (shaderName == null) { |
||||
return ""; |
||||
} |
||||
String shName = shaderName.get(type); |
||||
return shName != null ? shName : ""; |
||||
} |
||||
|
||||
//todo: make equals and hashCode work
|
||||
@Override |
||||
public boolean equals(Object obj) { |
||||
final ShaderKey other = (ShaderKey) obj; |
||||
if (name.equals(other.name) && getShaderName(Shader.ShaderType.Fragment).equals(other.getShaderName(Shader.ShaderType.Fragment))){ |
||||
if (defines != null && other.defines != null) { |
||||
return defines.equals(other.defines); |
||||
} else if (defines != null || other.defines != null) { |
||||
return false; |
||||
} else { |
||||
return true; |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
@Override |
||||
public int hashCode() { |
||||
if (cachedHashedCode == 0) { |
||||
int hash = 7; |
||||
hash = 41 * hash + name.hashCode(); |
||||
hash = 41 * hash + getShaderName(Shader.ShaderType.Fragment).hashCode(); |
||||
hash = getShaderName(Shader.ShaderType.Geometry) == null ? hash : 41 * hash + getShaderName(Shader.ShaderType.Geometry).hashCode(); |
||||
hash = getShaderName(Shader.ShaderType.TessellationControl) == null ? hash : 41 * hash + getShaderName(Shader.ShaderType.TessellationControl).hashCode(); |
||||
hash = getShaderName(Shader.ShaderType.TessellationEvaluation) == null ? hash : 41 * hash + getShaderName(Shader.ShaderType.TessellationEvaluation).hashCode(); |
||||
hash = 41 * hash + (defines != null ? defines.hashCode() : 0); |
||||
cachedHashedCode = hash; |
||||
} |
||||
return cachedHashedCode; |
||||
} |
||||
|
||||
public DefineList getDefines() { |
||||
return defines; |
||||
} |
||||
|
||||
public String getVertName(){ |
||||
return getShaderName(Shader.ShaderType.Vertex); |
||||
} |
||||
|
||||
public String getFragName() { |
||||
return getShaderName(Shader.ShaderType.Fragment); |
||||
} |
||||
|
||||
/** |
||||
* @deprecated Use {@link #getVertexShaderLanguage() } instead. |
||||
*/ |
||||
@Deprecated |
||||
public String getLanguage() { |
||||
return shaderLanguage.get(Shader.ShaderType.Vertex); |
||||
} |
||||
|
||||
public String getVertexShaderLanguage() { |
||||
return shaderLanguage.get(Shader.ShaderType.Vertex); |
||||
} |
||||
|
||||
public String getFragmentShaderLanguage() { |
||||
return shaderLanguage.get(Shader.ShaderType.Vertex); |
||||
} |
||||
|
||||
public boolean isUsesShaderNodes() { |
||||
return usesShaderNodes; |
||||
} |
||||
|
||||
public void setUsesShaderNodes(boolean usesShaderNodes) { |
||||
this.usesShaderNodes = usesShaderNodes; |
||||
} |
||||
|
||||
public Set<Shader.ShaderType> getUsedShaderPrograms(){ |
||||
return shaderName.keySet(); |
||||
} |
||||
|
||||
public String getShaderProgramLanguage(Shader.ShaderType shaderType){ |
||||
return shaderLanguage.get(shaderType); |
||||
} |
||||
|
||||
public String getShaderProgramName(Shader.ShaderType shaderType){ |
||||
return getShaderName(shaderType); |
||||
} |
||||
|
||||
@Override |
||||
public void write(JmeExporter ex) throws IOException{ |
||||
super.write(ex); |
||||
OutputCapsule oc = ex.getCapsule(this); |
||||
oc.write(shaderName.get(Shader.ShaderType.Fragment), "fragment_name", null); |
||||
oc.write(shaderName.get(Shader.ShaderType.Geometry), "geometry_name", null); |
||||
oc.write(shaderName.get(Shader.ShaderType.TessellationControl), "tessControl_name", null); |
||||
oc.write(shaderName.get(Shader.ShaderType.TessellationEvaluation), "tessEval_name", null); |
||||
oc.write(shaderLanguage.get(Shader.ShaderType.Vertex), "language", null); |
||||
oc.write(shaderLanguage.get(Shader.ShaderType.Fragment), "frag_language", null); |
||||
oc.write(shaderLanguage.get(Shader.ShaderType.Geometry), "geom_language", null); |
||||
oc.write(shaderLanguage.get(Shader.ShaderType.TessellationControl), "tsctrl_language", null); |
||||
oc.write(shaderLanguage.get(Shader.ShaderType.TessellationEvaluation), "tseval_language", null); |
||||
|
||||
} |
||||
|
||||
@Override |
||||
public void read(JmeImporter im) throws IOException{ |
||||
super.read(im); |
||||
InputCapsule ic = im.getCapsule(this); |
||||
shaderName.put(Shader.ShaderType.Vertex,name); |
||||
shaderName.put(Shader.ShaderType.Fragment,ic.readString("fragment_name", null)); |
||||
shaderName.put(Shader.ShaderType.Geometry,ic.readString("geometry_name", null)); |
||||
shaderName.put(Shader.ShaderType.TessellationControl,ic.readString("tessControl_name", null)); |
||||
shaderName.put(Shader.ShaderType.TessellationEvaluation,ic.readString("tessEval_name", null)); |
||||
shaderLanguage.put(Shader.ShaderType.Vertex,ic.readString("language", null)); |
||||
shaderLanguage.put(Shader.ShaderType.Fragment,ic.readString("frag_language", null)); |
||||
shaderLanguage.put(Shader.ShaderType.Geometry,ic.readString("geom_language", null)); |
||||
shaderLanguage.put(Shader.ShaderType.TessellationControl,ic.readString("tsctrl_language", null)); |
||||
shaderLanguage.put(Shader.ShaderType.TessellationEvaluation,ic.readString("tseval_language", null)); |
||||
} |
||||
|
||||
} |
||||
@ -0,0 +1,52 @@ |
||||
/* |
||||
* Copyright (c) 2009-2015 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.asset; |
||||
|
||||
import com.jme3.asset.plugins.ClasspathLocator; |
||||
import com.jme3.shader.plugins.GLSLLoader; |
||||
import com.jme3.system.JmeSystem; |
||||
import com.jme3.system.MockJmeSystemDelegate; |
||||
import org.junit.Test; |
||||
|
||||
public class LoadShaderSourceTest { |
||||
|
||||
@Test |
||||
public void testLoadShaderSource() { |
||||
JmeSystem.setSystemDelegate(new MockJmeSystemDelegate()); |
||||
AssetManager assetManager = new DesktopAssetManager(); |
||||
assetManager.registerLocator(null, ClasspathLocator.class); |
||||
assetManager.registerLoader(GLSLLoader.class, "frag"); |
||||
String showNormals = (String) assetManager.loadAsset("Common/MatDefs/Misc/ShowNormals.frag"); |
||||
System.out.println(showNormals); |
||||
} |
||||
|
||||
} |
||||
@ -0,0 +1,538 @@ |
||||
/* |
||||
* Copyright (c) 2009-2016 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.material; |
||||
|
||||
import com.jme3.asset.AssetManager; |
||||
import com.jme3.light.LightList; |
||||
import com.jme3.math.Matrix4f; |
||||
import com.jme3.renderer.RenderManager; |
||||
import com.jme3.scene.Geometry; |
||||
import com.jme3.scene.shape.Box; |
||||
import com.jme3.shader.Shader; |
||||
import com.jme3.shader.Uniform; |
||||
import com.jme3.shader.VarType; |
||||
import java.util.Arrays; |
||||
import java.util.HashSet; |
||||
import org.junit.Assert; |
||||
import org.junit.Test; |
||||
|
||||
import static com.jme3.scene.MPOTestUtils.*; |
||||
import com.jme3.shader.DefineList; |
||||
import com.jme3.system.NullRenderer; |
||||
import com.jme3.system.TestUtil; |
||||
import com.jme3.texture.Image.Format; |
||||
import com.jme3.texture.Texture; |
||||
import com.jme3.texture.Texture2D; |
||||
import java.util.HashMap; |
||||
import java.util.Map; |
||||
|
||||
/** |
||||
* Validates how {@link MatParamOverride MPOs} work on the material level. |
||||
* |
||||
* @author Kirill Vainer |
||||
*/ |
||||
public class MaterialMatParamOverrideTest { |
||||
|
||||
private static final HashSet<String> IGNORED_UNIFORMS = new HashSet<String>( |
||||
Arrays.asList(new String[]{"m_ParallaxHeight", "m_Shininess", "m_BackfaceShadows"})); |
||||
|
||||
@Test |
||||
public void testBoolMpoOnly() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMpo(mpoBool("UseMaterialColors", true)); |
||||
outDefines(def("MATERIAL_COLORS", VarType.Boolean, true)); |
||||
outUniforms(uniform("UseMaterialColors", VarType.Boolean, true)); |
||||
} |
||||
|
||||
@Test |
||||
public void testBoolMpOnly() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMp(mpoBool("UseMaterialColors", true)); |
||||
outDefines(def("MATERIAL_COLORS", VarType.Boolean, true)); |
||||
outUniforms(uniform("UseMaterialColors", VarType.Boolean, true)); |
||||
} |
||||
|
||||
@Test |
||||
public void testBoolOverrideFalse() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMp(mpoBool("UseMaterialColors", true)); |
||||
inputMpo(mpoBool("UseMaterialColors", false)); |
||||
outDefines(); |
||||
outUniforms(uniform("UseMaterialColors", VarType.Boolean, false)); |
||||
} |
||||
|
||||
@Test |
||||
public void testBoolOverrideTrue() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMp(mpoBool("UseMaterialColors", false)); |
||||
inputMpo(mpoBool("UseMaterialColors", true)); |
||||
outDefines(def("MATERIAL_COLORS", VarType.Boolean, true)); |
||||
outUniforms(uniform("UseMaterialColors", VarType.Boolean, true)); |
||||
} |
||||
|
||||
@Test |
||||
public void testFloatMpoOnly() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMpo(mpoFloat("AlphaDiscardThreshold", 3.12f)); |
||||
outDefines(def("DISCARD_ALPHA", VarType.Float, 3.12f)); |
||||
outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 3.12f)); |
||||
} |
||||
|
||||
@Test |
||||
public void testFloatMpOnly() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMp(mpoFloat("AlphaDiscardThreshold", 3.12f)); |
||||
outDefines(def("DISCARD_ALPHA", VarType.Float, 3.12f)); |
||||
outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 3.12f)); |
||||
} |
||||
|
||||
@Test |
||||
public void testFloatOverride() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMp(mpoFloat("AlphaDiscardThreshold", 3.12f)); |
||||
inputMpo(mpoFloat("AlphaDiscardThreshold", 2.79f)); |
||||
outDefines(def("DISCARD_ALPHA", VarType.Float, 2.79f)); |
||||
outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 2.79f)); |
||||
} |
||||
|
||||
@Test |
||||
public void testMpoDisable() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMp(mpoFloat("AlphaDiscardThreshold", 3.12f)); |
||||
|
||||
MatParamOverride override = mpoFloat("AlphaDiscardThreshold", 2.79f); |
||||
inputMpo(override); |
||||
outDefines(def("DISCARD_ALPHA", VarType.Float, 2.79f)); |
||||
outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 2.79f)); |
||||
|
||||
reset(); |
||||
override.setEnabled(false); |
||||
outDefines(def("DISCARD_ALPHA", VarType.Float, 3.12f)); |
||||
outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 3.12f)); |
||||
|
||||
reset(); |
||||
override.setEnabled(true); |
||||
outDefines(def("DISCARD_ALPHA", VarType.Float, 2.79f)); |
||||
outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 2.79f)); |
||||
} |
||||
|
||||
@Test |
||||
public void testIntMpoOnly() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMpo(mpoInt("NumberOfBones", 1234)); |
||||
outDefines(def("NUM_BONES", VarType.Int, 1234)); |
||||
outUniforms(uniform("NumberOfBones", VarType.Int, 1234)); |
||||
} |
||||
|
||||
@Test |
||||
public void testIntMpOnly() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMp(mpoInt("NumberOfBones", 1234)); |
||||
outDefines(def("NUM_BONES", VarType.Int, 1234)); |
||||
outUniforms(uniform("NumberOfBones", VarType.Int, 1234)); |
||||
} |
||||
|
||||
@Test |
||||
public void testIntOverride() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMp(mpoInt("NumberOfBones", 1234)); |
||||
inputMpo(mpoInt("NumberOfBones", 4321)); |
||||
outDefines(def("NUM_BONES", VarType.Int, 4321)); |
||||
outUniforms(uniform("NumberOfBones", VarType.Int, 4321)); |
||||
} |
||||
|
||||
@Test |
||||
public void testMatrixArray() { |
||||
Matrix4f[] matrices = new Matrix4f[]{ |
||||
new Matrix4f() |
||||
}; |
||||
|
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMpo(mpoMatrix4Array("BoneMatrices", matrices)); |
||||
outDefines(); |
||||
outUniforms(uniform("BoneMatrices", VarType.Matrix4Array, matrices)); |
||||
} |
||||
|
||||
@Test |
||||
public void testNonExistentParameter() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMpo(mpoInt("NonExistent", 4321)); |
||||
outDefines(); |
||||
outUniforms(); |
||||
} |
||||
|
||||
@Test |
||||
public void testWrongType() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMpo(mpoInt("UseMaterialColors", 4321)); |
||||
outDefines(); |
||||
outUniforms(); |
||||
} |
||||
|
||||
@Test |
||||
public void testParamOnly() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
inputMpo(mpoFloat("ShadowMapSize", 3.12f)); |
||||
outDefines(); |
||||
outUniforms(uniform("ShadowMapSize", VarType.Float, 3.12f)); |
||||
} |
||||
|
||||
@Test |
||||
public void testRemove() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
|
||||
reset(); |
||||
inputMp(mpoInt("NumberOfBones", 1234)); |
||||
outDefines(def("NUM_BONES", VarType.Int, 1234)); |
||||
outUniforms(uniform("NumberOfBones", VarType.Int, 1234)); |
||||
|
||||
reset(); |
||||
inputMpo(mpoInt("NumberOfBones", 4321)); |
||||
outDefines(def("NUM_BONES", VarType.Int, 4321)); |
||||
outUniforms(uniform("NumberOfBones", VarType.Int, 4321)); |
||||
|
||||
reset(); |
||||
geometry.clearMatParamOverrides(); |
||||
geometry.updateGeometricState(); |
||||
outDefines(def("NUM_BONES", VarType.Int, 1234)); |
||||
outUniforms(uniform("NumberOfBones", VarType.Int, 1234)); |
||||
|
||||
reset(); |
||||
geometry.getMaterial().clearParam("NumberOfBones"); |
||||
outDefines(); |
||||
outUniforms(); |
||||
|
||||
reset(); |
||||
inputMpo(mpoInt("NumberOfBones", 4321)); |
||||
outDefines(def("NUM_BONES", VarType.Int, 4321)); |
||||
outUniforms(uniform("NumberOfBones", VarType.Int, 4321)); |
||||
|
||||
reset(); |
||||
inputMp(mpoInt("NumberOfBones", 1234)); |
||||
outDefines(def("NUM_BONES", VarType.Int, 4321)); |
||||
outUniforms(uniform("NumberOfBones", VarType.Int, 4321)); |
||||
} |
||||
|
||||
public void testRemoveOverride() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
|
||||
reset(); |
||||
inputMp(mpoInt("NumberOfBones", 1234)); |
||||
outDefines(def("NUM_BONES", VarType.Int, 1234)); |
||||
outUniforms(uniform("NumberOfBones", VarType.Int, 1234)); |
||||
|
||||
reset(); |
||||
inputMpo(mpoInt("NumberOfBones", 4321)); |
||||
outDefines(def("NUM_BONES", VarType.Int, 4321)); |
||||
outUniforms(uniform("NumberOfBones", VarType.Int, 4321)); |
||||
|
||||
reset(); |
||||
geometry.clearMatParamOverrides(); |
||||
outDefines(def("NUM_BONES", VarType.Int, 1234)); |
||||
outUniforms(uniform("NumberOfBones", VarType.Int, 1234)); |
||||
} |
||||
|
||||
@Test |
||||
public void testRemoveMpoOnly() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
|
||||
reset(); |
||||
inputMpo(mpoInt("NumberOfBones", 4321)); |
||||
outDefines(def("NUM_BONES", VarType.Int, 4321)); |
||||
outUniforms(uniform("NumberOfBones", VarType.Int, 4321)); |
||||
|
||||
reset(); |
||||
geometry.clearMatParamOverrides(); |
||||
geometry.updateGeometricState(); |
||||
outDefines(); |
||||
outUniforms(); |
||||
} |
||||
|
||||
@Test |
||||
public void testTextureMpoOnly() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
Texture2D tex = new Texture2D(128, 128, Format.RGBA8); |
||||
|
||||
inputMpo(mpoTexture2D("DiffuseMap", tex)); |
||||
outDefines(def("DIFFUSEMAP", VarType.Texture2D, tex)); |
||||
outUniforms(uniform("DiffuseMap", VarType.Int, 0)); |
||||
outTextures(tex); |
||||
} |
||||
|
||||
@Test |
||||
public void testTextureOverride() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
Texture2D tex1 = new Texture2D(128, 128, Format.RGBA8); |
||||
Texture2D tex2 = new Texture2D(128, 128, Format.RGBA8); |
||||
|
||||
inputMp(mpoTexture2D("DiffuseMap", tex1)); |
||||
inputMpo(mpoTexture2D("DiffuseMap", tex2)); |
||||
|
||||
outDefines(def("DIFFUSEMAP", VarType.Texture2D, tex2)); |
||||
outUniforms(uniform("DiffuseMap", VarType.Int, 0)); |
||||
outTextures(tex2); |
||||
} |
||||
|
||||
@Test |
||||
public void testRemoveTexture() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
Texture2D tex = new Texture2D(128, 128, Format.RGBA8); |
||||
|
||||
reset(); |
||||
inputMpo(mpoTexture2D("DiffuseMap", tex)); |
||||
outDefines(def("DIFFUSEMAP", VarType.Texture2D, tex)); |
||||
outUniforms(uniform("DiffuseMap", VarType.Int, 0)); |
||||
outTextures(tex); |
||||
|
||||
reset(); |
||||
geometry.clearMatParamOverrides(); |
||||
geometry.updateGeometricState(); |
||||
outDefines(); |
||||
outUniforms(); |
||||
outTextures(); |
||||
} |
||||
|
||||
@Test |
||||
public void testRemoveTextureOverride() { |
||||
material("Common/MatDefs/Light/Lighting.j3md"); |
||||
Texture2D tex1 = new Texture2D(128, 128, Format.RGBA8); |
||||
Texture2D tex2 = new Texture2D(128, 128, Format.RGBA8); |
||||
|
||||
reset(); |
||||
inputMp(mpoTexture2D("DiffuseMap", tex1)); |
||||
outDefines(def("DIFFUSEMAP", VarType.Texture2D, tex1)); |
||||
outUniforms(uniform("DiffuseMap", VarType.Int, 0)); |
||||
outTextures(tex1); |
||||
|
||||
reset(); |
||||
inputMpo(mpoTexture2D("DiffuseMap", tex2)); |
||||
outDefines(def("DIFFUSEMAP", VarType.Texture2D, tex2)); |
||||
outUniforms(uniform("DiffuseMap", VarType.Int, 0)); |
||||
outTextures(tex2); |
||||
|
||||
reset(); |
||||
geometry.clearMatParamOverrides(); |
||||
geometry.updateGeometricState(); |
||||
outDefines(def("DIFFUSEMAP", VarType.Texture2D, tex1)); |
||||
outUniforms(uniform("DiffuseMap", VarType.Int, 0)); |
||||
outTextures(tex1); |
||||
} |
||||
|
||||
private static final class Define { |
||||
|
||||
public String name; |
||||
public VarType type; |
||||
public Object value; |
||||
|
||||
@Override |
||||
public int hashCode() { |
||||
int hash = 3; |
||||
hash = 89 * hash + this.name.hashCode(); |
||||
hash = 89 * hash + this.type.hashCode(); |
||||
hash = 89 * hash + this.value.hashCode(); |
||||
return hash; |
||||
} |
||||
|
||||
@Override |
||||
public boolean equals(Object obj) { |
||||
final Define other = (Define) obj; |
||||
return this.name.equals(other.name) && this.type.equals(other.type) && this.value.equals(other.value); |
||||
} |
||||
} |
||||
|
||||
private final Geometry geometry = new Geometry("geometry", new Box(1, 1, 1)); |
||||
private final LightList lightList = new LightList(geometry); |
||||
|
||||
private final NullRenderer renderer = new NullRenderer() { |
||||
@Override |
||||
public void setShader(Shader shader) { |
||||
MaterialMatParamOverrideTest.this.usedShader = shader; |
||||
evaluated = true; |
||||
} |
||||
|
||||
@Override |
||||
public void setTexture(int unit, Texture texture) { |
||||
MaterialMatParamOverrideTest.this.usedTextures[unit] = texture; |
||||
} |
||||
}; |
||||
private final RenderManager renderManager = new RenderManager(renderer); |
||||
|
||||
private boolean evaluated = false; |
||||
private Shader usedShader = null; |
||||
private final Texture[] usedTextures = new Texture[32]; |
||||
|
||||
private void inputMp(MatParam... params) { |
||||
if (evaluated) { |
||||
throw new IllegalStateException(); |
||||
} |
||||
Material mat = geometry.getMaterial(); |
||||
for (MatParam param : params) { |
||||
mat.setParam(param.getName(), param.getVarType(), param.getValue()); |
||||
} |
||||
} |
||||
|
||||
private void inputMpo(MatParamOverride... overrides) { |
||||
if (evaluated) { |
||||
throw new IllegalStateException(); |
||||
} |
||||
for (MatParamOverride override : overrides) { |
||||
geometry.addMatParamOverride(override); |
||||
} |
||||
geometry.updateGeometricState(); |
||||
} |
||||
|
||||
private void reset() { |
||||
evaluated = false; |
||||
usedShader = null; |
||||
Arrays.fill(usedTextures, null); |
||||
} |
||||
|
||||
private Define def(String name, VarType type, Object value) { |
||||
Define d = new Define(); |
||||
d.name = name; |
||||
d.type = type; |
||||
d.value = value; |
||||
return d; |
||||
} |
||||
|
||||
private Uniform uniform(String name, VarType type, Object value) { |
||||
Uniform u = new Uniform(); |
||||
u.setName("m_" + name); |
||||
u.setValue(type, value); |
||||
return u; |
||||
} |
||||
|
||||
private void material(String path) { |
||||
AssetManager assetManager = TestUtil.createAssetManager(); |
||||
geometry.setMaterial(new Material(assetManager, path)); |
||||
} |
||||
|
||||
private void evaluateTechniqueDef() { |
||||
Assert.assertFalse(evaluated); |
||||
Material mat = geometry.getMaterial(); |
||||
mat.render(geometry, lightList, renderManager); |
||||
Assert.assertTrue(evaluated); |
||||
} |
||||
|
||||
private void outTextures(Texture... textures) { |
||||
for (int i = 0; i < usedTextures.length; i++) { |
||||
if (i < textures.length) { |
||||
Assert.assertSame(textures[i], usedTextures[i]); |
||||
} else { |
||||
Assert.assertNull(usedTextures[i]); |
||||
} |
||||
} |
||||
} |
||||
|
||||
private void outDefines(Define... expectedDefinesArray) { |
||||
Map<String, Define> nameToDefineMap = new HashMap<String, Define>(); |
||||
for (Define define : expectedDefinesArray) { |
||||
nameToDefineMap.put(define.name, define); |
||||
} |
||||
|
||||
if (!evaluated) { |
||||
evaluateTechniqueDef(); |
||||
} |
||||
|
||||
Material mat = geometry.getMaterial(); |
||||
Technique tech = mat.getActiveTechnique(); |
||||
TechniqueDef def = tech.getDef(); |
||||
DefineList actualDefines = tech.getDynamicDefines(); |
||||
|
||||
String[] defineNames = def.getDefineNames(); |
||||
VarType[] defineTypes = def.getDefineTypes(); |
||||
|
||||
Assert.assertEquals(defineNames.length, defineTypes.length); |
||||
|
||||
for (int index = 0; index < defineNames.length; index++) { |
||||
String name = defineNames[index]; |
||||
VarType type = defineTypes[index]; |
||||
Define expectedDefine = nameToDefineMap.remove(name); |
||||
Object expectedValue = null; |
||||
|
||||
if (expectedDefine != null) { |
||||
Assert.assertEquals(expectedDefine.type, type); |
||||
expectedValue = expectedDefine.value; |
||||
} |
||||
|
||||
switch (type) { |
||||
case Boolean: |
||||
if (expectedValue != null) { |
||||
Assert.assertEquals((boolean) (Boolean) expectedValue, actualDefines.getBoolean(index)); |
||||
} else { |
||||
Assert.assertEquals(false, actualDefines.getBoolean(index)); |
||||
} |
||||
break; |
||||
case Int: |
||||
if (expectedValue != null) { |
||||
Assert.assertEquals((int) (Integer) expectedValue, actualDefines.getInt(index)); |
||||
} else { |
||||
Assert.assertEquals(0, actualDefines.getInt(index)); |
||||
} |
||||
break; |
||||
case Float: |
||||
if (expectedValue != null) { |
||||
Assert.assertEquals((float) (Float) expectedValue, actualDefines.getFloat(index), 0f); |
||||
} else { |
||||
Assert.assertEquals(0f, actualDefines.getFloat(index), 0f); |
||||
} |
||||
break; |
||||
default: |
||||
if (expectedValue != null) { |
||||
Assert.assertEquals(1, actualDefines.getInt(index)); |
||||
} else { |
||||
Assert.assertEquals(0, actualDefines.getInt(index)); |
||||
} |
||||
break; |
||||
} |
||||
} |
||||
|
||||
Assert.assertTrue(nameToDefineMap.isEmpty()); |
||||
} |
||||
|
||||
private void outUniforms(Uniform... uniforms) { |
||||
HashSet<Uniform> actualUniforms = new HashSet<>(); |
||||
|
||||
for (Uniform uniform : usedShader.getUniformMap().values()) { |
||||
if (uniform.getName().startsWith("m_") |
||||
&& !IGNORED_UNIFORMS.contains(uniform.getName())) { |
||||
actualUniforms.add(uniform); |
||||
} |
||||
} |
||||
|
||||
HashSet<Uniform> expectedUniforms = new HashSet<>(Arrays.asList(uniforms)); |
||||
|
||||
if (!expectedUniforms.equals(actualUniforms)) { |
||||
Assert.fail("Uniform lists must match: " + expectedUniforms + " != " + actualUniforms); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,342 @@ |
||||
/* |
||||
* Copyright (c) 2009-2015 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.renderer; |
||||
|
||||
import com.jme3.asset.AssetManager; |
||||
import com.jme3.material.Material; |
||||
import com.jme3.math.ColorRGBA; |
||||
import com.jme3.renderer.queue.GeometryList; |
||||
import com.jme3.renderer.queue.OpaqueComparator; |
||||
import com.jme3.scene.Geometry; |
||||
import com.jme3.scene.Mesh; |
||||
import com.jme3.scene.shape.Box; |
||||
import com.jme3.system.TestUtil; |
||||
import com.jme3.texture.Image; |
||||
import com.jme3.texture.Image.Format; |
||||
import com.jme3.texture.Texture; |
||||
import com.jme3.texture.Texture2D; |
||||
import com.jme3.texture.image.ColorSpace; |
||||
import com.jme3.util.BufferUtils; |
||||
import java.nio.ByteBuffer; |
||||
import java.util.HashSet; |
||||
import java.util.Set; |
||||
import org.junit.Before; |
||||
import org.junit.Ignore; |
||||
import org.junit.Test; |
||||
|
||||
public class OpaqueComparatorTest { |
||||
|
||||
private final Mesh mesh = new Box(1,1,1); |
||||
private Camera cam = new Camera(1, 1); |
||||
private RenderManager renderManager; |
||||
private AssetManager assetManager; |
||||
private OpaqueComparator comparator = new OpaqueComparator(); |
||||
|
||||
@Before |
||||
public void setUp() { |
||||
assetManager = TestUtil.createAssetManager(); |
||||
renderManager = TestUtil.createRenderManager(); |
||||
comparator.setCamera(cam); |
||||
} |
||||
|
||||
/** |
||||
* Given a correctly sorted list of materials, check if the |
||||
* opaque comparator can sort a reversed list of them. |
||||
* |
||||
* Each material will be cloned so that none of them will be equal to each other |
||||
* in reference, forcing the comparator to compare the material sort ID. |
||||
* |
||||
* E.g. for a list of materials A, B, C, the following list will be generated: |
||||
* <pre>C, B, A, C, B, A, C, B, A</pre>, it should result in |
||||
* <pre>A, A, A, B, B, B, C, C, C</pre>. |
||||
* |
||||
* @param materials The pre-sorted list of materials to check sorting for. |
||||
*/ |
||||
private void testSort(Material ... materials) { |
||||
GeometryList gl = new GeometryList(comparator); |
||||
for (int g = 0; g < 5; g++) { |
||||
for (int i = materials.length - 1; i >= 0; i--) { |
||||
Geometry geom = new Geometry("geom", mesh); |
||||
Material clonedMaterial = materials[i].clone(); |
||||
|
||||
if (materials[i].getActiveTechnique() != null) { |
||||
String techniqueName = materials[i].getActiveTechnique().getDef().getName(); |
||||
clonedMaterial.selectTechnique(techniqueName, renderManager); |
||||
} else { |
||||
clonedMaterial.selectTechnique("Default", renderManager); |
||||
} |
||||
|
||||
geom.setMaterial(clonedMaterial); |
||||
gl.add(geom); |
||||
} |
||||
} |
||||
gl.sort(); |
||||
|
||||
for (int i = 0; i < gl.size(); i++) { |
||||
Material mat = gl.get(i).getMaterial(); |
||||
String sortId = Integer.toHexString(mat.getSortId()).toUpperCase(); |
||||
System.out.print(sortId + "\t"); |
||||
System.out.println(mat); |
||||
} |
||||
|
||||
Set<String> alreadySeen = new HashSet<String>(); |
||||
Material current = null; |
||||
for (int i = 0; i < gl.size(); i++) { |
||||
Material mat = gl.get(i).getMaterial(); |
||||
if (current == null) { |
||||
current = mat; |
||||
} else if (!current.getName().equals(mat.getName())) { |
||||
assert !alreadySeen.contains(mat.getName()); |
||||
alreadySeen.add(current.getName()); |
||||
current = mat; |
||||
} |
||||
} |
||||
|
||||
for (int i = 0; i < materials.length; i++) { |
||||
for (int g = 0; g < 5; g++) { |
||||
int index = i * 5 + g; |
||||
Material mat1 = gl.get(index).getMaterial(); |
||||
Material mat2 = materials[i]; |
||||
assert mat1.getName().equals(mat2.getName()) : |
||||
mat1.getName() + " != " + mat2.getName() + " for index " + index; |
||||
} |
||||
} |
||||
} |
||||
|
||||
@Test |
||||
public void testSortByMaterialDef() { |
||||
Material lightingMat = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
Material particleMat = new Material(assetManager, "Common/MatDefs/Misc/Particle.j3md"); |
||||
Material unshadedMat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md"); |
||||
Material skyMat = new Material(assetManager, "Common/MatDefs/Misc/Sky.j3md"); |
||||
|
||||
lightingMat.setName("MatLight"); |
||||
particleMat.setName("MatParticle"); |
||||
unshadedMat.setName("MatUnshaded"); |
||||
skyMat.setName("MatSky"); |
||||
testSort(skyMat, lightingMat, particleMat, unshadedMat); |
||||
} |
||||
|
||||
@Test |
||||
public void testSortByTechnique() { |
||||
Material lightingMatDefault = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
Material lightingPreShadow = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
Material lightingPostShadow = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
Material lightingMatPreNormalPass = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
Material lightingMatGBuf = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
Material lightingMatGlow = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
|
||||
lightingMatDefault.setName("TechDefault"); |
||||
lightingMatDefault.selectTechnique("Default", renderManager); |
||||
|
||||
lightingPostShadow.setName("TechPostShad"); |
||||
lightingPostShadow.selectTechnique("PostShadow", renderManager); |
||||
|
||||
lightingPreShadow.setName("TechPreShad"); |
||||
lightingPreShadow.selectTechnique("PreShadow", renderManager); |
||||
|
||||
lightingMatPreNormalPass.setName("TechNorm"); |
||||
lightingMatPreNormalPass.selectTechnique("PreNormalPass", renderManager); |
||||
|
||||
lightingMatGBuf.setName("TechGBuf"); |
||||
lightingMatGBuf.selectTechnique("GBuf", renderManager); |
||||
|
||||
lightingMatGlow.setName("TechGlow"); |
||||
lightingMatGlow.selectTechnique("Glow", renderManager); |
||||
|
||||
testSort(lightingMatGlow, lightingPreShadow, lightingMatPreNormalPass, |
||||
lightingMatDefault, lightingPostShadow, lightingMatGBuf); |
||||
} |
||||
|
||||
@Test(expected = AssertionError.class) |
||||
public void testNoSortByParam() { |
||||
Material sameMat1 = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md"); |
||||
Material sameMat2 = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md"); |
||||
|
||||
sameMat1.setName("MatRed"); |
||||
sameMat1.setColor("Color", ColorRGBA.Red); |
||||
|
||||
sameMat2.setName("MatBlue"); |
||||
sameMat2.setColor("Color", ColorRGBA.Blue); |
||||
|
||||
testSort(sameMat1, sameMat2); |
||||
} |
||||
|
||||
private Texture createTexture(String name) { |
||||
ByteBuffer bb = BufferUtils.createByteBuffer(3); |
||||
Image image = new Image(Format.RGB8, 1, 1, bb, ColorSpace.sRGB); |
||||
Texture2D texture = new Texture2D(image); |
||||
texture.setName(name); |
||||
return texture; |
||||
} |
||||
|
||||
@Test |
||||
public void testSortByTexture() { |
||||
Material texture1Mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md"); |
||||
Material texture2Mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md"); |
||||
Material texture3Mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md"); |
||||
|
||||
Texture tex1 = createTexture("A"); |
||||
tex1.getImage().setId(1); |
||||
|
||||
Texture tex2 = createTexture("B"); |
||||
tex2.getImage().setId(2); |
||||
|
||||
Texture tex3 = createTexture("C"); |
||||
tex3.getImage().setId(3); |
||||
|
||||
texture1Mat.setName("TexA"); |
||||
texture1Mat.setTexture("ColorMap", tex1); |
||||
|
||||
texture2Mat.setName("TexB"); |
||||
texture2Mat.setTexture("ColorMap", tex2); |
||||
|
||||
texture3Mat.setName("TexC"); |
||||
texture3Mat.setTexture("ColorMap", tex3); |
||||
|
||||
testSort(texture1Mat, texture2Mat, texture3Mat); |
||||
} |
||||
|
||||
@Test |
||||
public void testSortByShaderDefines() { |
||||
Material lightingMat = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
Material lightingMatVColor = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
Material lightingMatVLight = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
Material lightingMatTC = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
Material lightingMatVColorLight = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
Material lightingMatTCVColorLight = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
|
||||
lightingMat.setName("DefNone"); |
||||
|
||||
lightingMatVColor.setName("DefVC"); |
||||
lightingMatVColor.setBoolean("UseVertexColor", true); |
||||
|
||||
lightingMatVLight.setName("DefVL"); |
||||
lightingMatVLight.setBoolean("VertexLighting", true); |
||||
|
||||
lightingMatTC.setName("DefTC"); |
||||
lightingMatTC.setBoolean("SeparateTexCoord", true); |
||||
|
||||
lightingMatVColorLight.setName("DefVCVL"); |
||||
lightingMatVColorLight.setBoolean("UseVertexColor", true); |
||||
lightingMatVColorLight.setBoolean("VertexLighting", true); |
||||
|
||||
lightingMatTCVColorLight.setName("DefVCVLTC"); |
||||
lightingMatTCVColorLight.setBoolean("UseVertexColor", true); |
||||
lightingMatTCVColorLight.setBoolean("VertexLighting", true); |
||||
lightingMatTCVColorLight.setBoolean("SeparateTexCoord", true); |
||||
|
||||
testSort(lightingMat, lightingMatVColor, lightingMatVLight, |
||||
lightingMatVColorLight, lightingMatTC, lightingMatTCVColorLight); |
||||
} |
||||
|
||||
@Test |
||||
public void testSortByAll() { |
||||
Material matBase1 = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md"); |
||||
Material matBase2 = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md"); |
||||
|
||||
Texture texBase = createTexture("BASE"); |
||||
texBase.getImage().setId(1); |
||||
Texture tex1 = createTexture("1"); |
||||
tex1.getImage().setId(2); |
||||
Texture tex2 = createTexture("2"); |
||||
tex2.getImage().setId(3); |
||||
|
||||
matBase1.setName("BASE"); |
||||
matBase1.selectTechnique("Default", renderManager); |
||||
matBase1.setBoolean("UseVertexColor", true); |
||||
matBase1.setTexture("DiffuseMap", texBase); |
||||
|
||||
Material mat1100 = matBase1.clone(); |
||||
mat1100.setName("1100"); |
||||
mat1100.selectTechnique("PreShadow", renderManager); |
||||
|
||||
Material mat1101 = matBase1.clone(); |
||||
mat1101.setName("1101"); |
||||
mat1101.selectTechnique("PreShadow", renderManager); |
||||
mat1101.setTexture("DiffuseMap", tex1); |
||||
|
||||
Material mat1102 = matBase1.clone(); |
||||
mat1102.setName("1102"); |
||||
mat1102.selectTechnique("PreShadow", renderManager); |
||||
mat1102.setTexture("DiffuseMap", tex2); |
||||
|
||||
Material mat1110 = matBase1.clone(); |
||||
mat1110.setName("1110"); |
||||
mat1110.selectTechnique("PreShadow", renderManager); |
||||
mat1110.setFloat("AlphaDiscardThreshold", 2f); |
||||
|
||||
Material mat1120 = matBase1.clone(); |
||||
mat1120.setName("1120"); |
||||
mat1120.selectTechnique("PreShadow", renderManager); |
||||
mat1120.setBoolean("UseInstancing", true); |
||||
|
||||
Material mat1121 = matBase1.clone(); |
||||
mat1121.setName("1121"); |
||||
mat1121.selectTechnique("PreShadow", renderManager); |
||||
mat1121.setBoolean("UseInstancing", true); |
||||
mat1121.setTexture("DiffuseMap", tex1); |
||||
|
||||
Material mat1122 = matBase1.clone(); |
||||
mat1122.setName("1122"); |
||||
mat1122.selectTechnique("PreShadow", renderManager); |
||||
mat1122.setBoolean("UseInstancing", true); |
||||
mat1122.setTexture("DiffuseMap", tex2); |
||||
|
||||
Material mat1140 = matBase1.clone(); |
||||
mat1140.setName("1140"); |
||||
mat1140.selectTechnique("PreShadow", renderManager); |
||||
mat1140.setFloat("AlphaDiscardThreshold", 2f); |
||||
mat1140.setBoolean("UseInstancing", true); |
||||
|
||||
Material mat1200 = matBase1.clone(); |
||||
mat1200.setName("1200"); |
||||
mat1200.selectTechnique("PostShadow", renderManager); |
||||
|
||||
Material mat1210 = matBase1.clone(); |
||||
mat1210.setName("1210"); |
||||
mat1210.selectTechnique("PostShadow", renderManager); |
||||
mat1210.setFloat("AlphaDiscardThreshold", 2f); |
||||
|
||||
Material mat1220 = matBase1.clone(); |
||||
mat1220.setName("1220"); |
||||
mat1220.selectTechnique("PostShadow", renderManager); |
||||
mat1220.setBoolean("UseInstancing", true); |
||||
|
||||
Material mat2000 = matBase2.clone(); |
||||
mat2000.setName("2000"); |
||||
|
||||
testSort(mat1100, mat1101, mat1102, mat1110, |
||||
mat1120, mat1121, mat1122, mat1140, |
||||
mat1200, mat1210, mat1220, mat2000); |
||||
} |
||||
} |
||||
@ -0,0 +1,173 @@ |
||||
/* |
||||
* Copyright (c) 2009-2016 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.scene; |
||||
|
||||
import com.jme3.material.MatParamOverride; |
||||
import com.jme3.math.Matrix4f; |
||||
import com.jme3.renderer.Camera; |
||||
import com.jme3.shader.VarType; |
||||
import com.jme3.texture.Texture2D; |
||||
import java.lang.reflect.Field; |
||||
import java.util.HashSet; |
||||
import java.util.Set; |
||||
import static org.junit.Assert.assertEquals; |
||||
|
||||
public class MPOTestUtils { |
||||
|
||||
private static final Camera DUMMY_CAM = new Camera(640, 480); |
||||
|
||||
private static final SceneGraphVisitor VISITOR = new SceneGraphVisitor() { |
||||
@Override |
||||
public void visit(Spatial spatial) { |
||||
validateSubScene(spatial); |
||||
} |
||||
}; |
||||
|
||||
private static void validateSubScene(Spatial scene) { |
||||
scene.checkCulling(DUMMY_CAM); |
||||
|
||||
Set<MatParamOverride> actualOverrides = new HashSet<MatParamOverride>(); |
||||
for (MatParamOverride override : scene.getWorldMatParamOverrides()) { |
||||
actualOverrides.add(override); |
||||
} |
||||
|
||||
Set<MatParamOverride> expectedOverrides = new HashSet<MatParamOverride>(); |
||||
Spatial current = scene; |
||||
while (current != null) { |
||||
for (MatParamOverride override : current.getLocalMatParamOverrides()) { |
||||
expectedOverrides.add(override); |
||||
} |
||||
current = current.getParent(); |
||||
} |
||||
|
||||
assertEquals("For " + scene, expectedOverrides, actualOverrides); |
||||
} |
||||
|
||||
public static void validateScene(Spatial scene) { |
||||
scene.updateGeometricState(); |
||||
scene.depthFirstTraversal(VISITOR); |
||||
} |
||||
|
||||
public static MatParamOverride mpoInt(String name, int value) { |
||||
return new MatParamOverride(VarType.Int, name, value); |
||||
} |
||||
|
||||
public static MatParamOverride mpoBool(String name, boolean value) { |
||||
return new MatParamOverride(VarType.Boolean, name, value); |
||||
} |
||||
|
||||
public static MatParamOverride mpoFloat(String name, float value) { |
||||
return new MatParamOverride(VarType.Float, name, value); |
||||
} |
||||
|
||||
public static MatParamOverride mpoMatrix4Array(String name, Matrix4f[] value) { |
||||
return new MatParamOverride(VarType.Matrix4Array, name, value); |
||||
} |
||||
|
||||
public static MatParamOverride mpoTexture2D(String name, Texture2D texture) { |
||||
return new MatParamOverride(VarType.Texture2D, name, texture); |
||||
} |
||||
|
||||
private static int getRefreshFlags(Spatial scene) { |
||||
try { |
||||
Field refreshFlagsField = Spatial.class.getDeclaredField("refreshFlags"); |
||||
refreshFlagsField.setAccessible(true); |
||||
return (Integer) refreshFlagsField.get(scene); |
||||
} catch (NoSuchFieldException ex) { |
||||
throw new AssertionError(ex); |
||||
} catch (SecurityException ex) { |
||||
throw new AssertionError(ex); |
||||
} catch (IllegalArgumentException ex) { |
||||
throw new AssertionError(ex); |
||||
} catch (IllegalAccessException ex) { |
||||
throw new AssertionError(ex); |
||||
} |
||||
} |
||||
|
||||
private static void dumpSceneRF(Spatial scene, String indent, boolean last, int refreshFlagsMask) { |
||||
StringBuilder sb = new StringBuilder(); |
||||
|
||||
sb.append(indent); |
||||
if (last) { |
||||
if (!indent.isEmpty()) { |
||||
sb.append("└─"); |
||||
} else { |
||||
sb.append(" "); |
||||
} |
||||
indent += " "; |
||||
} else { |
||||
sb.append("├─"); |
||||
indent += "│ "; |
||||
} |
||||
sb.append(scene.getName()); |
||||
int rf = getRefreshFlags(scene) & refreshFlagsMask; |
||||
if (rf != 0) { |
||||
sb.append("("); |
||||
if ((rf & 0x1) != 0) { |
||||
sb.append("T"); |
||||
} |
||||
if ((rf & 0x2) != 0) { |
||||
sb.append("B"); |
||||
} |
||||
if ((rf & 0x4) != 0) { |
||||
sb.append("L"); |
||||
} |
||||
if ((rf & 0x8) != 0) { |
||||
sb.append("l"); |
||||
} |
||||
if ((rf & 0x10) != 0) { |
||||
sb.append("O"); |
||||
} |
||||
sb.append(")"); |
||||
} |
||||
|
||||
if (!scene.getLocalMatParamOverrides().isEmpty()) { |
||||
sb.append(" [MPO]"); |
||||
} |
||||
|
||||
System.out.println(sb); |
||||
|
||||
if (scene instanceof Node) { |
||||
Node node = (Node) scene; |
||||
int childIndex = 0; |
||||
for (Spatial child : node.getChildren()) { |
||||
boolean childLast = childIndex == node.getQuantity() - 1; |
||||
dumpSceneRF(child, indent, childLast, refreshFlagsMask); |
||||
childIndex++; |
||||
} |
||||
} |
||||
} |
||||
|
||||
public static void dumpSceneRF(Spatial scene, int refreshFlagsMask) { |
||||
dumpSceneRF(scene, "", true, refreshFlagsMask); |
||||
} |
||||
} |
||||
@ -0,0 +1,278 @@ |
||||
/* |
||||
* Copyright (c) 2009-2016 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.scene; |
||||
|
||||
import com.jme3.asset.AssetManager; |
||||
import com.jme3.export.binary.BinaryExporter; |
||||
import com.jme3.material.MatParamOverride; |
||||
import org.junit.Test; |
||||
|
||||
import static com.jme3.scene.MPOTestUtils.*; |
||||
import static org.junit.Assert.*; |
||||
|
||||
import com.jme3.system.TestUtil; |
||||
import java.util.ArrayList; |
||||
import java.util.List; |
||||
|
||||
/** |
||||
* Validates how {@link MatParamOverride MPOs} work on the scene level. |
||||
* |
||||
* @author Kirill Vainer |
||||
*/ |
||||
public class SceneMatParamOverrideTest { |
||||
|
||||
private static Node createDummyScene() { |
||||
Node scene = new Node("Scene Node"); |
||||
|
||||
Node a = new Node("A"); |
||||
Node b = new Node("B"); |
||||
|
||||
Node c = new Node("C"); |
||||
Node d = new Node("D"); |
||||
|
||||
Node e = new Node("E"); |
||||
Node f = new Node("F"); |
||||
|
||||
Node g = new Node("G"); |
||||
Node h = new Node("H"); |
||||
Node j = new Node("J"); |
||||
|
||||
scene.attachChild(a); |
||||
scene.attachChild(b); |
||||
|
||||
a.attachChild(c); |
||||
a.attachChild(d); |
||||
|
||||
b.attachChild(e); |
||||
b.attachChild(f); |
||||
|
||||
c.attachChild(g); |
||||
c.attachChild(h); |
||||
c.attachChild(j); |
||||
|
||||
return scene; |
||||
} |
||||
|
||||
@Test |
||||
public void testOverrides_Empty() { |
||||
Node n = new Node("Node"); |
||||
assertTrue(n.getLocalMatParamOverrides().isEmpty()); |
||||
assertTrue(n.getWorldMatParamOverrides().isEmpty()); |
||||
|
||||
n.updateGeometricState(); |
||||
assertTrue(n.getLocalMatParamOverrides().isEmpty()); |
||||
assertTrue(n.getWorldMatParamOverrides().isEmpty()); |
||||
} |
||||
|
||||
@Test |
||||
public void testOverrides_AddRemove() { |
||||
MatParamOverride override = mpoBool("Test", true); |
||||
Node n = new Node("Node"); |
||||
|
||||
n.removeMatParamOverride(override); |
||||
assertTrue(n.getLocalMatParamOverrides().isEmpty()); |
||||
assertTrue(n.getWorldMatParamOverrides().isEmpty()); |
||||
|
||||
n.addMatParamOverride(override); |
||||
|
||||
assertSame(n.getLocalMatParamOverrides().get(0), override); |
||||
assertTrue(n.getWorldMatParamOverrides().isEmpty()); |
||||
n.updateGeometricState(); |
||||
|
||||
assertSame(n.getLocalMatParamOverrides().get(0), override); |
||||
assertSame(n.getWorldMatParamOverrides().get(0), override); |
||||
|
||||
n.removeMatParamOverride(override); |
||||
assertTrue(n.getLocalMatParamOverrides().isEmpty()); |
||||
assertSame(n.getWorldMatParamOverrides().get(0), override); |
||||
|
||||
n.updateGeometricState(); |
||||
assertTrue(n.getLocalMatParamOverrides().isEmpty()); |
||||
assertTrue(n.getWorldMatParamOverrides().isEmpty()); |
||||
} |
||||
|
||||
@Test |
||||
public void testOverrides_Clear() { |
||||
MatParamOverride override = mpoBool("Test", true); |
||||
Node n = new Node("Node"); |
||||
|
||||
n.clearMatParamOverrides(); |
||||
assertTrue(n.getLocalMatParamOverrides().isEmpty()); |
||||
assertTrue(n.getWorldMatParamOverrides().isEmpty()); |
||||
|
||||
n.addMatParamOverride(override); |
||||
n.clearMatParamOverrides(); |
||||
assertTrue(n.getLocalMatParamOverrides().isEmpty()); |
||||
assertTrue(n.getWorldMatParamOverrides().isEmpty()); |
||||
|
||||
n.addMatParamOverride(override); |
||||
n.updateGeometricState(); |
||||
n.clearMatParamOverrides(); |
||||
assertTrue(n.getLocalMatParamOverrides().isEmpty()); |
||||
assertSame(n.getWorldMatParamOverrides().get(0), override); |
||||
|
||||
n.updateGeometricState(); |
||||
assertTrue(n.getLocalMatParamOverrides().isEmpty()); |
||||
assertTrue(n.getWorldMatParamOverrides().isEmpty()); |
||||
|
||||
n.addMatParamOverride(override); |
||||
n.clearMatParamOverrides(); |
||||
n.updateGeometricState(); |
||||
assertTrue(n.getLocalMatParamOverrides().isEmpty()); |
||||
assertTrue(n.getWorldMatParamOverrides().isEmpty()); |
||||
} |
||||
|
||||
@Test |
||||
public void testOverrides_AddAfterAttach() { |
||||
Node scene = createDummyScene(); |
||||
scene.updateGeometricState(); |
||||
|
||||
Node root = new Node("Root Node"); |
||||
root.updateGeometricState(); |
||||
|
||||
root.attachChild(scene); |
||||
scene.getChild("A").addMatParamOverride(mpoInt("val", 5)); |
||||
|
||||
validateScene(root); |
||||
} |
||||
|
||||
@Test |
||||
public void testOverrides_AddBeforeAttach() { |
||||
Node scene = createDummyScene(); |
||||
scene.getChild("A").addMatParamOverride(mpoInt("val", 5)); |
||||
scene.updateGeometricState(); |
||||
|
||||
Node root = new Node("Root Node"); |
||||
root.updateGeometricState(); |
||||
|
||||
root.attachChild(scene); |
||||
|
||||
validateScene(root); |
||||
} |
||||
|
||||
@Test |
||||
public void testOverrides_RemoveBeforeAttach() { |
||||
Node scene = createDummyScene(); |
||||
scene.updateGeometricState(); |
||||
|
||||
Node root = new Node("Root Node"); |
||||
root.updateGeometricState(); |
||||
|
||||
scene.getChild("A").addMatParamOverride(mpoInt("val", 5)); |
||||
validateScene(scene); |
||||
|
||||
scene.getChild("A").clearMatParamOverrides(); |
||||
validateScene(scene); |
||||
|
||||
root.attachChild(scene); |
||||
validateScene(root); |
||||
} |
||||
|
||||
@Test |
||||
public void testOverrides_RemoveAfterAttach() { |
||||
Node scene = createDummyScene(); |
||||
scene.updateGeometricState(); |
||||
|
||||
Node root = new Node("Root Node"); |
||||
root.updateGeometricState(); |
||||
|
||||
scene.getChild("A").addMatParamOverride(mpoInt("val", 5)); |
||||
|
||||
root.attachChild(scene); |
||||
validateScene(root); |
||||
|
||||
scene.getChild("A").clearMatParamOverrides(); |
||||
validateScene(root); |
||||
} |
||||
|
||||
@Test |
||||
public void testOverrides_IdenticalNames() { |
||||
Node scene = createDummyScene(); |
||||
|
||||
scene.getChild("A").addMatParamOverride(mpoInt("val", 5)); |
||||
scene.getChild("C").addMatParamOverride(mpoInt("val", 7)); |
||||
|
||||
validateScene(scene); |
||||
} |
||||
|
||||
@Test |
||||
public void testOverrides_CloningScene_DoesntCloneMPO() { |
||||
Node originalScene = createDummyScene(); |
||||
|
||||
originalScene.getChild("A").addMatParamOverride(mpoInt("int", 5)); |
||||
originalScene.getChild("A").addMatParamOverride(mpoBool("bool", true)); |
||||
originalScene.getChild("A").addMatParamOverride(mpoFloat("float", 3.12f)); |
||||
|
||||
Node clonedScene = originalScene.clone(false); |
||||
|
||||
validateScene(clonedScene); |
||||
validateScene(originalScene); |
||||
|
||||
List<MatParamOverride> clonedOverrides = clonedScene.getChild("A").getLocalMatParamOverrides(); |
||||
List<MatParamOverride> originalOverrides = originalScene.getChild("A").getLocalMatParamOverrides(); |
||||
|
||||
assertNotSame(clonedOverrides, originalOverrides); |
||||
assertEquals(clonedOverrides, originalOverrides); |
||||
|
||||
for (int i = 0; i < clonedOverrides.size(); i++) { |
||||
assertNotSame(clonedOverrides.get(i), originalOverrides.get(i)); |
||||
assertEquals(clonedOverrides.get(i), originalOverrides.get(i)); |
||||
} |
||||
} |
||||
|
||||
@Test |
||||
public void testOverrides_SaveAndLoad_KeepsMPOs() { |
||||
MatParamOverride override = mpoInt("val", 5); |
||||
Node scene = createDummyScene(); |
||||
scene.getChild("A").addMatParamOverride(override); |
||||
|
||||
AssetManager assetManager = TestUtil.createAssetManager(); |
||||
Node loadedScene = BinaryExporter.saveAndLoad(assetManager, scene); |
||||
|
||||
Node root = new Node("Root Node"); |
||||
root.attachChild(loadedScene); |
||||
validateScene(root); |
||||
validateScene(scene); |
||||
|
||||
assertNotSame(override, loadedScene.getChild("A").getLocalMatParamOverrides().get(0)); |
||||
assertEquals(override, loadedScene.getChild("A").getLocalMatParamOverrides().get(0)); |
||||
} |
||||
|
||||
@Test |
||||
public void testEquals() { |
||||
assertEquals(mpoInt("val", 5), mpoInt("val", 5)); |
||||
assertEquals(mpoBool("val", true), mpoBool("val", true)); |
||||
assertNotEquals(mpoInt("val", 5), mpoInt("val", 6)); |
||||
assertNotEquals(mpoInt("val1", 5), mpoInt("val2", 5)); |
||||
assertNotEquals(mpoBool("val", true), mpoInt("val", 1)); |
||||
} |
||||
} |
||||
@ -0,0 +1,300 @@ |
||||
/* |
||||
* Copyright (c) 2009-2015 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.shader; |
||||
|
||||
import com.jme3.math.FastMath; |
||||
import java.util.Arrays; |
||||
import java.util.HashMap; |
||||
import java.util.List; |
||||
import org.junit.Test; |
||||
|
||||
import static org.junit.Assert.*; |
||||
|
||||
public class DefineListTest { |
||||
|
||||
private static final List<String> DEFINE_NAMES = Arrays.asList("BOOL_VAR", "INT_VAR", "FLOAT_VAR"); |
||||
private static final List<VarType> DEFINE_TYPES = Arrays.asList(VarType.Boolean, VarType.Int, VarType.Float); |
||||
private static final int NUM_DEFINES = DEFINE_NAMES.size(); |
||||
private static final int BOOL_VAR = 0; |
||||
private static final int INT_VAR = 1; |
||||
private static final int FLOAT_VAR = 2; |
||||
private static final DefineList EMPTY = new DefineList(NUM_DEFINES); |
||||
|
||||
@Test |
||||
public void testHashCollision() { |
||||
DefineList dl1 = new DefineList(64); |
||||
DefineList dl2 = new DefineList(64); |
||||
|
||||
// Try to cause a hash collision
|
||||
// (since bit #32 is aliased to bit #1 in 32-bit ints)
|
||||
dl1.set(0, 123); |
||||
dl1.set(32, 0); |
||||
|
||||
dl2.set(32, 0); |
||||
dl2.set(0, 123); |
||||
|
||||
assert dl1.hashCode() == dl2.hashCode(); |
||||
assert dl1.equals(dl2); |
||||
} |
||||
|
||||
@Test |
||||
public void testGetSet() { |
||||
DefineList dl = new DefineList(NUM_DEFINES); |
||||
|
||||
assertFalse(dl.getBoolean(BOOL_VAR)); |
||||
assertEquals(dl.getInt(INT_VAR), 0); |
||||
assertEquals(dl.getFloat(FLOAT_VAR), 0f, 0f); |
||||
|
||||
dl.set(BOOL_VAR, true); |
||||
dl.set(INT_VAR, -1); |
||||
dl.set(FLOAT_VAR, Float.NaN); |
||||
|
||||
assertTrue(dl.getBoolean(BOOL_VAR)); |
||||
assertEquals(dl.getInt(INT_VAR), -1); |
||||
assertTrue(Float.isNaN(dl.getFloat(FLOAT_VAR))); |
||||
} |
||||
|
||||
private String generateSource(DefineList dl) { |
||||
StringBuilder sb = new StringBuilder(); |
||||
dl.generateSource(sb, DEFINE_NAMES, DEFINE_TYPES); |
||||
return sb.toString(); |
||||
} |
||||
|
||||
@Test |
||||
public void testSourceInitial() { |
||||
DefineList dl = new DefineList(NUM_DEFINES); |
||||
assert dl.hashCode() == 0; |
||||
assert generateSource(dl).equals(""); |
||||
} |
||||
|
||||
@Test |
||||
public void testSourceBooleanDefine() { |
||||
DefineList dl = new DefineList(NUM_DEFINES); |
||||
|
||||
dl.set(BOOL_VAR, true); |
||||
assert dl.hashCode() == 1; |
||||
assert generateSource(dl).equals("#define BOOL_VAR 1\n"); |
||||
|
||||
dl.set(BOOL_VAR, false); |
||||
assert dl.hashCode() == 0; |
||||
assert generateSource(dl).equals(""); |
||||
} |
||||
|
||||
@Test |
||||
public void testSourceIntDefine() { |
||||
DefineList dl = new DefineList(NUM_DEFINES); |
||||
|
||||
int hashCodeWithInt = 1 << INT_VAR; |
||||
|
||||
dl.set(INT_VAR, 123); |
||||
assert dl.hashCode() == hashCodeWithInt; |
||||
assert generateSource(dl).equals("#define INT_VAR 123\n"); |
||||
|
||||
dl.set(INT_VAR, 0); |
||||
assert dl.hashCode() == 0; |
||||
assert generateSource(dl).equals(""); |
||||
|
||||
dl.set(INT_VAR, -99); |
||||
assert dl.hashCode() == hashCodeWithInt; |
||||
assert generateSource(dl).equals("#define INT_VAR -99\n"); |
||||
|
||||
dl.set(INT_VAR, Integer.MAX_VALUE); |
||||
assert dl.hashCode() == hashCodeWithInt; |
||||
assert generateSource(dl).equals("#define INT_VAR 2147483647\n"); |
||||
} |
||||
|
||||
@Test |
||||
public void testSourceFloatDefine() { |
||||
DefineList dl = new DefineList(NUM_DEFINES); |
||||
|
||||
dl.set(FLOAT_VAR, 1f); |
||||
assert dl.hashCode() == (1 << FLOAT_VAR); |
||||
assert generateSource(dl).equals("#define FLOAT_VAR 1.0\n"); |
||||
|
||||
dl.set(FLOAT_VAR, 0f); |
||||
assert dl.hashCode() == 0; |
||||
assert generateSource(dl).equals(""); |
||||
|
||||
dl.set(FLOAT_VAR, -1f); |
||||
assert generateSource(dl).equals("#define FLOAT_VAR -1.0\n"); |
||||
|
||||
dl.set(FLOAT_VAR, FastMath.FLT_EPSILON); |
||||
assert generateSource(dl).equals("#define FLOAT_VAR 1.1920929E-7\n"); |
||||
|
||||
dl.set(FLOAT_VAR, FastMath.PI); |
||||
assert generateSource(dl).equals("#define FLOAT_VAR 3.1415927\n"); |
||||
|
||||
try { |
||||
dl.set(FLOAT_VAR, Float.NaN); |
||||
generateSource(dl); |
||||
assert false; |
||||
} catch (IllegalArgumentException ex) { } |
||||
|
||||
try { |
||||
dl.set(FLOAT_VAR, Float.POSITIVE_INFINITY); |
||||
generateSource(dl); |
||||
assert false; |
||||
} catch (IllegalArgumentException ex) { } |
||||
|
||||
try { |
||||
dl.set(FLOAT_VAR, Float.NEGATIVE_INFINITY); |
||||
generateSource(dl); |
||||
assert false; |
||||
} catch (IllegalArgumentException ex) { } |
||||
} |
||||
|
||||
@Test |
||||
public void testEqualsAndHashCode() { |
||||
DefineList dl1 = new DefineList(NUM_DEFINES); |
||||
DefineList dl2 = new DefineList(NUM_DEFINES); |
||||
|
||||
assertTrue(dl1.hashCode() == 0); |
||||
assertEquals(dl1, dl2); |
||||
|
||||
dl1.set(BOOL_VAR, true); |
||||
|
||||
assertTrue(dl1.hashCode() == 1); |
||||
assertNotSame(dl1, dl2); |
||||
|
||||
dl2.set(BOOL_VAR, true); |
||||
|
||||
assertEquals(dl1, dl2); |
||||
|
||||
dl1.set(INT_VAR, 2); |
||||
|
||||
assertTrue(dl1.hashCode() == (1|2)); |
||||
assertNotSame(dl1, dl2); |
||||
|
||||
dl2.set(INT_VAR, 2); |
||||
|
||||
assertEquals(dl1, dl2); |
||||
|
||||
dl1.set(BOOL_VAR, false); |
||||
|
||||
assertTrue(dl1.hashCode() == 2); |
||||
assertNotSame(dl1, dl2); |
||||
} |
||||
|
||||
@Test |
||||
public void testDeepClone() { |
||||
DefineList dl1 = new DefineList(NUM_DEFINES); |
||||
DefineList dl2 = dl1.deepClone(); |
||||
|
||||
assertFalse(dl1 == dl2); |
||||
assertTrue(dl1.equals(dl2)); |
||||
assertTrue(dl1.hashCode() == dl2.hashCode()); |
||||
|
||||
dl1.set(BOOL_VAR, true); |
||||
dl2 = dl1.deepClone(); |
||||
|
||||
assertTrue(dl1.equals(dl2)); |
||||
assertTrue(dl1.hashCode() == dl2.hashCode()); |
||||
|
||||
dl1.set(INT_VAR, 123); |
||||
|
||||
assertFalse(dl1.equals(dl2)); |
||||
assertFalse(dl1.hashCode() == dl2.hashCode()); |
||||
|
||||
dl2 = dl1.deepClone(); |
||||
|
||||
assertTrue(dl1.equals(dl2)); |
||||
assertTrue(dl1.hashCode() == dl2.hashCode()); |
||||
} |
||||
|
||||
@Test |
||||
public void testGenerateSource() { |
||||
DefineList dl = new DefineList(NUM_DEFINES); |
||||
|
||||
assertEquals("", generateSource(dl)); |
||||
|
||||
dl.set(BOOL_VAR, true); |
||||
|
||||
assertEquals("#define BOOL_VAR 1\n", generateSource(dl)); |
||||
|
||||
dl.set(INT_VAR, 123); |
||||
|
||||
assertEquals("#define BOOL_VAR 1\n" + |
||||
"#define INT_VAR 123\n", generateSource(dl)); |
||||
|
||||
dl.set(BOOL_VAR, false); |
||||
|
||||
assertEquals("#define INT_VAR 123\n", generateSource(dl)); |
||||
|
||||
dl.set(BOOL_VAR, true); |
||||
|
||||
// should have predictable ordering based on defineId
|
||||
assertEquals("#define BOOL_VAR 1\n" + |
||||
"#define INT_VAR 123\n", generateSource(dl)); |
||||
} |
||||
|
||||
private static String doLookup(HashMap<DefineList, String> map, boolean boolVal, int intVal, float floatVal) { |
||||
DefineList dl = new DefineList(NUM_DEFINES); |
||||
dl.set(BOOL_VAR, boolVal); |
||||
dl.set(INT_VAR, intVal); |
||||
dl.set(FLOAT_VAR, floatVal); |
||||
return map.get(dl); |
||||
} |
||||
|
||||
@Test |
||||
public void testHashLookup() { |
||||
String STR_EMPTY = "This is an empty define list"; |
||||
String STR_INT = "This define list has an int value"; |
||||
String STR_BOOL = "This define list just has boolean value set"; |
||||
String STR_BOOL_INT = "This define list has both a boolean and int value"; |
||||
String STR_BOOL_INT_FLOAT = "This define list has a boolean, int, and float value"; |
||||
|
||||
HashMap<DefineList, String> map = new HashMap<DefineList, String>(); |
||||
|
||||
DefineList lookup = new DefineList(NUM_DEFINES); |
||||
|
||||
map.put(lookup.deepClone(), STR_EMPTY); |
||||
|
||||
lookup.set(BOOL_VAR, true); |
||||
map.put(lookup.deepClone(), STR_BOOL); |
||||
|
||||
lookup.set(BOOL_VAR, false); |
||||
lookup.set(INT_VAR, 123); |
||||
map.put(lookup.deepClone(), STR_INT); |
||||
|
||||
lookup.set(BOOL_VAR, true); |
||||
map.put(lookup.deepClone(), STR_BOOL_INT); |
||||
|
||||
lookup.set(FLOAT_VAR, FastMath.PI); |
||||
map.put(lookup.deepClone(), STR_BOOL_INT_FLOAT); |
||||
|
||||
assertEquals(doLookup(map, false, 0, 0f), STR_EMPTY); |
||||
assertEquals(doLookup(map, false, 123, 0f), STR_INT); |
||||
assertEquals(doLookup(map, true, 0, 0f), STR_BOOL); |
||||
assertEquals(doLookup(map, true, 123, 0f), STR_BOOL_INT); |
||||
assertEquals(doLookup(map, true, 123, FastMath.PI), STR_BOOL_INT_FLOAT); |
||||
} |
||||
} |
||||
@ -0,0 +1,78 @@ |
||||
/* |
||||
* Copyright (c) 2009-2015 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.system; |
||||
|
||||
import com.jme3.audio.AudioRenderer; |
||||
import java.io.IOException; |
||||
import java.io.OutputStream; |
||||
import java.net.URL; |
||||
import java.nio.ByteBuffer; |
||||
|
||||
public class MockJmeSystemDelegate extends JmeSystemDelegate { |
||||
|
||||
@Override |
||||
public void writeImageFile(OutputStream outStream, String format, ByteBuffer imageData, int width, int height) throws IOException { |
||||
} |
||||
|
||||
@Override |
||||
public void showErrorDialog(String message) { |
||||
} |
||||
|
||||
@Override |
||||
public boolean showSettingsDialog(AppSettings sourceSettings, boolean loadFromRegistry) { |
||||
return false; |
||||
} |
||||
|
||||
@Override |
||||
public URL getPlatformAssetConfigURL() { |
||||
return Thread.currentThread().getContextClassLoader().getResource("com/jme3/asset/General.cfg"); |
||||
} |
||||
|
||||
@Override |
||||
public JmeContext newContext(AppSettings settings, JmeContext.Type contextType) { |
||||
return null; |
||||
} |
||||
|
||||
@Override |
||||
public AudioRenderer newAudioRenderer(AppSettings settings) { |
||||
return null; |
||||
} |
||||
|
||||
@Override |
||||
public void initialize(AppSettings settings) { |
||||
} |
||||
|
||||
@Override |
||||
public void showSoftKeyboard(boolean show) { |
||||
} |
||||
|
||||
} |
||||
@ -0,0 +1,55 @@ |
||||
/* |
||||
* Copyright (c) 2009-2015 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.system; |
||||
|
||||
import com.jme3.asset.AssetConfig; |
||||
import com.jme3.asset.AssetManager; |
||||
import com.jme3.asset.DesktopAssetManager; |
||||
import com.jme3.renderer.RenderManager; |
||||
import java.util.logging.Level; |
||||
import java.util.logging.Logger; |
||||
|
||||
public class TestUtil { |
||||
|
||||
static { |
||||
JmeSystem.setSystemDelegate(new MockJmeSystemDelegate()); |
||||
} |
||||
|
||||
public static AssetManager createAssetManager() { |
||||
Logger.getLogger(AssetConfig.class.getName()).setLevel(Level.OFF); |
||||
return new DesktopAssetManager(true); |
||||
} |
||||
|
||||
public static RenderManager createRenderManager() { |
||||
return new RenderManager(new NullRenderer()); |
||||
} |
||||
} |
||||
@ -1,156 +0,0 @@ |
||||
/* |
||||
* 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 jme3test.app; |
||||
|
||||
import com.jme3.system.NativeLibraryLoader; |
||||
import java.io.File; |
||||
import java.util.logging.Level; |
||||
import java.util.logging.Logger; |
||||
|
||||
/** |
||||
* Try to load some natives. |
||||
* |
||||
* @author Kirill Vainer |
||||
*/ |
||||
public class TestNativeLoader { |
||||
|
||||
private static final File WORKING_FOLDER = new File(System.getProperty("user.dir")); |
||||
|
||||
private static void tryLoadLwjgl() { |
||||
NativeLibraryLoader.loadNativeLibrary("lwjgl", true); |
||||
System.out.println("Succeeded in loading LWJGL.\n\tVersion: " + |
||||
org.lwjgl.Sys.getVersion()); |
||||
} |
||||
|
||||
private static void tryLoadJinput() { |
||||
NativeLibraryLoader.loadNativeLibrary("jinput", true); |
||||
NativeLibraryLoader.loadNativeLibrary("jinput-dx8", true); |
||||
|
||||
net.java.games.input.ControllerEnvironment ce = |
||||
net.java.games.input.ControllerEnvironment.getDefaultEnvironment(); |
||||
if (ce.isSupported()) { |
||||
net.java.games.input.Controller[] c = |
||||
ce.getControllers(); |
||||
|
||||
System.out.println("Succeeded in loading JInput.\n\tVersion: " + |
||||
net.java.games.util.Version.getVersion()); |
||||
} |
||||
} |
||||
|
||||
private static void tryLoadOpenAL() { |
||||
NativeLibraryLoader.loadNativeLibrary("openal", true); |
||||
|
||||
try { |
||||
org.lwjgl.openal.AL.create(); |
||||
String renderer = org.lwjgl.openal.AL10.alGetString(org.lwjgl.openal.AL10.AL_RENDERER); |
||||
String vendor = org.lwjgl.openal.AL10.alGetString(org.lwjgl.openal.AL10.AL_VENDOR); |
||||
String version = org.lwjgl.openal.AL10.alGetString(org.lwjgl.openal.AL10.AL_VERSION); |
||||
System.out.println("Succeeded in loading OpenAL."); |
||||
System.out.println("\tVersion: " + version); |
||||
} catch (org.lwjgl.LWJGLException ex) { |
||||
throw new RuntimeException(ex); |
||||
} finally { |
||||
if (org.lwjgl.openal.AL.isCreated()) { |
||||
org.lwjgl.openal.AL.destroy(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
private static void tryLoadOpenGL() { |
||||
org.lwjgl.opengl.Pbuffer pb = null; |
||||
try { |
||||
pb = new org.lwjgl.opengl.Pbuffer(1, 1, new org.lwjgl.opengl.PixelFormat(0, 0, 0), null); |
||||
pb.makeCurrent(); |
||||
String version = org.lwjgl.opengl.GL11.glGetString(org.lwjgl.opengl.GL11.GL_VERSION); |
||||
System.out.println("Succeeded in loading OpenGL.\n\tVersion: " + version); |
||||
} catch (org.lwjgl.LWJGLException ex) { |
||||
throw new RuntimeException(ex); |
||||
} finally { |
||||
if (pb != null) { |
||||
pb.destroy(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
private static void tryLoadBulletJme() { |
||||
if (NativeLibraryLoader.isUsingNativeBullet()) { |
||||
NativeLibraryLoader.loadNativeLibrary("bulletjme", true); |
||||
|
||||
com.jme3.bullet.PhysicsSpace physSpace = new com.jme3.bullet.PhysicsSpace(); |
||||
|
||||
System.out.println("Succeeded in loading BulletJme."); |
||||
} else { |
||||
System.out.println("Native bullet not included. Cannot test loading."); |
||||
} |
||||
} |
||||
|
||||
private static void cleanupNativesFolder(File folder) { |
||||
for (File file : folder.listFiles()) { |
||||
String lowerCaseName = file.getName().toLowerCase(); |
||||
if (lowerCaseName.contains("lwjgl") || |
||||
lowerCaseName.contains("jinput") || |
||||
lowerCaseName.contains("openal") || |
||||
lowerCaseName.contains("bulletjme")) { |
||||
file.delete(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
public static void main(String[] args) { |
||||
Logger.getLogger("").getHandlers()[0].setLevel(Level.WARNING); |
||||
Logger.getLogger(NativeLibraryLoader.class.getName()).setLevel(Level.ALL); |
||||
|
||||
// Get a bit more output from LWJGL about issues.
|
||||
// System.setProperty("org.lwjgl.util.Debug", "true");
|
||||
|
||||
// Extracting to working folder is no brainer.
|
||||
// Choose some random path, then load LWJGL.
|
||||
File customNativesFolder = new File("CustomNativesFolder"); |
||||
customNativesFolder.mkdirs(); |
||||
|
||||
if (!customNativesFolder.isDirectory()) { |
||||
throw new IllegalStateException("Failed to make custom natives folder"); |
||||
} |
||||
|
||||
// Let's cleanup our folders first.
|
||||
cleanupNativesFolder(WORKING_FOLDER); |
||||
cleanupNativesFolder(customNativesFolder); |
||||
|
||||
NativeLibraryLoader.setCustomExtractionFolder(customNativesFolder.getAbsolutePath()); |
||||
|
||||
tryLoadLwjgl(); |
||||
tryLoadOpenGL(); |
||||
tryLoadOpenAL(); |
||||
tryLoadJinput(); |
||||
tryLoadBulletJme(); |
||||
} |
||||
} |
||||
@ -0,0 +1,92 @@ |
||||
/* |
||||
* Copyright (c) 2009-2016 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 jme3test.material; |
||||
|
||||
import com.jme3.app.SimpleApplication; |
||||
import com.jme3.input.KeyInput; |
||||
import com.jme3.input.controls.ActionListener; |
||||
import com.jme3.input.controls.KeyTrigger; |
||||
import com.jme3.material.MatParamOverride; |
||||
import com.jme3.material.Material; |
||||
import com.jme3.math.ColorRGBA; |
||||
import com.jme3.scene.Geometry; |
||||
import com.jme3.scene.shape.Box; |
||||
import com.jme3.shader.VarType; |
||||
|
||||
/** |
||||
* Test if {@link MatParamOverride}s are working correctly. |
||||
* |
||||
* @author Kirill Vainer |
||||
*/ |
||||
public class TestMatParamOverride extends SimpleApplication { |
||||
|
||||
private Box box = new Box(1, 1, 1); |
||||
private MatParamOverride override = new MatParamOverride(VarType.Vector4, "Color", ColorRGBA.Yellow); |
||||
|
||||
public static void main(String[] args) { |
||||
TestMatParamOverride app = new TestMatParamOverride(); |
||||
app.start(); |
||||
} |
||||
|
||||
private void createBox(float location, ColorRGBA color) { |
||||
Geometry geom = new Geometry("Box", box); |
||||
Material mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md"); |
||||
mat.setColor("Color", color); |
||||
geom.setMaterial(mat); |
||||
geom.move(location, 0, 0); |
||||
rootNode.attachChild(geom); |
||||
} |
||||
|
||||
@Override |
||||
public void simpleInitApp() { |
||||
inputManager.setCursorVisible(true); |
||||
|
||||
createBox(-3, ColorRGBA.Red); |
||||
createBox(0, ColorRGBA.Green); |
||||
createBox(3, ColorRGBA.Blue); |
||||
|
||||
inputManager.addMapping("override", new KeyTrigger(KeyInput.KEY_SPACE)); |
||||
inputManager.addListener(new ActionListener() { |
||||
@Override |
||||
public void onAction(String name, boolean isPressed, float tpf) { |
||||
if (name.equals("override") && isPressed) { |
||||
if (!rootNode.getLocalMatParamOverrides().isEmpty()) { |
||||
rootNode.clearMatParamOverrides(); |
||||
} else { |
||||
rootNode.addMatParamOverride(override); |
||||
} |
||||
System.out.println(rootNode.getLocalMatParamOverrides()); |
||||
} |
||||
} |
||||
}, "override"); |
||||
} |
||||
} |
||||
Loading…
Reference in new issue