com.jme3.material.RenderState Maven / Gradle / Ivy
Show all versions of jme3-core Show documentation
/*
* Copyright (c) 2009-2023 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.*;
import com.jme3.scene.Mesh;
import java.io.IOException;
/**
* RenderState specifies material rendering properties that cannot
* be controlled by a shader on a {@link Material}. The properties
* allow manipulation of rendering features such as depth testing, alpha blending,
* face culling, stencil operations, and much more.
*
* @author Kirill Vainer
*/
public class RenderState implements Cloneable, Savable {
/**
* The DEFAULT render state is the one used by default
* on all materials unless changed otherwise by the user.
*
*
* It has the following properties:
*
* - Back Face Culling
* - Depth Testing Enabled
* - Depth Writing Enabled
*
*/
public static final RenderState DEFAULT = new RenderState();
/**
* The NULL render state is identical to the {@link RenderState#DEFAULT}
* render state except that depth testing and face culling are disabled.
*/
public static final RenderState NULL = new RenderState();
/**
* The ADDITIONAL render state is identical to the
* {@link RenderState#DEFAULT} render state except that all apply
* values are set to false. This allows the ADDITIONAL render
* state to be combined with other state but only influencing values
* that were changed from the original.
*/
public static final RenderState ADDITIONAL = new RenderState();
/**
* TestFunction specifies the testing function for stencil test
* function.
*
*
* The reference value given in the stencil command is the input value while
* the reference is the value already in the stencil buffer.
*/
public enum TestFunction {
/**
* The test always fails
*/
Never,
/**
* The test succeeds if the input value is equal to the reference value.
*/
Equal,
/**
* The test succeeds if the input value is less than the reference value.
*/
Less,
/**
* The test succeeds if the input value is less than or equal to
* the reference value.
*/
LessOrEqual,
/**
* The test succeeds if the input value is greater than the reference value.
*/
Greater,
/**
* The test succeeds if the input value is greater than or equal to
* the reference value.
*/
GreaterOrEqual,
/**
* The test succeeds if the input value does not equal the
* reference value.
*/
NotEqual,
/**
* The test always passes
*/
Always
}
/**
* BlendEquation specifies the blending equation to combine
* pixels.
*/
public enum BlendEquation {
/**
* Sets the blend equation so that the source and destination data are
* added. (Default) Clamps to [0,1] Useful for things like antialiasing
* and transparency.
*/
Add,
/**
* Sets the blend equation so that the source and destination data are
* subtracted (Src - Dest). Clamps to [0,1] Falls back to Add if
* supportsSubtract is false.
*/
Subtract,
/**
* Same as Subtract, but the order is reversed (Dst - Src). Clamps to
* [0,1] Falls back to Add if supportsSubtract is false.
*/
ReverseSubtract,
/**
* Sets the blend equation so that each component of the result color is
* the minimum of the corresponding components of the source and
* destination colors. This and Max are useful for applications that
* analyze image data (image thresholding against a constant color, for
* example). Falls back to Add if supportsMinMax is false.
*/
Min,
/**
* Sets the blend equation so that each component of the result color is
* the maximum of the corresponding components of the source and
* destination colors. This and Min are useful for applications that
* analyze image data (image thresholding against a constant color, for
* example). Falls back to Add if supportsMinMax is false.
*/
Max
}
/**
* BlendEquationAlpha specifies the blending equation to
* combine pixels for the alpha component.
*/
public enum BlendEquationAlpha {
/**
* Sets the blend equation to be the same as the one defined by
* {@link #blendEquation}.
*
*/
InheritColor,
/**
* Sets the blend equation so that the source and destination data are
* added. (Default) Clamps to [0,1] Useful for things like antialiasing
* and transparency.
*/
Add,
/**
* Sets the blend equation so that the source and destination data are
* subtracted (Src - Dest). Clamps to [0,1] Falls back to Add if
* supportsSubtract is false.
*/
Subtract,
/**
* Same as Subtract, but the order is reversed (Dst - Src). Clamps to
* [0,1] Falls back to Add if supportsSubtract is false.
*/
ReverseSubtract,
/**
* Sets the blend equation so that the result alpha is the minimum of
* the source alpha and destination alpha. This and Max are useful for
* applications that analyze image data (image thresholding against a
* constant color, for example). Falls back to Add if supportsMinMax is
* false.
*/
Min,
/**
* sSets the blend equation so that the result alpha is the maximum of
* the source alpha and destination alpha. This and Min are useful for
* applications that analyze image data (image thresholding against a
* constant color, for example). Falls back to Add if supportsMinMax is
* false.
*/
Max
}
/**
* BlendFunc defines the blending functions for use with
* BlendMode.Custom.
* Source color components are referred to as (R_s0, G_s0, B_s0, A_s0).
* Destination color components are referred to as (R_d, G_d, B_d, A_d).
*/
public enum BlendFunc {
/**
* RGB Factor (0, 0, 0), Alpha Factor (0)
*/
Zero,
/**
* RGB Factor (1, 1, 1), Alpha Factor (1)
*/
One,
/**
* RGB Factor (R_s0, G_s0, B_s0), Alpha Factor (A_s0)
*/
Src_Color,
/**
* RGB Factor (1-R_s0, 1-G_s0, 1-B_s0), Alpha Factor (1-A_s0)
*/
One_Minus_Src_Color,
/**
* RGB Factor (R_d, G_d, B_d), Alpha Factor (A_d)
*/
Dst_Color,
/**
* RGB Factor (1-R_d, 1-G_d, 1-B_d), Alpha Factor (1-A_d)
*/
One_Minus_Dst_Color,
/**
* RGB Factor (A_s0, A_s0, A_s0), Alpha Factor (A_s0)
*/
Src_Alpha,
/**
* RGB Factor (1-A_s0, 1-A_s0, 1-A_s0), Alpha Factor (1-A_s0)
*/
One_Minus_Src_Alpha,
/**
* RGB Factor (A_d, A_d, A_d), Alpha Factor (A_d)
*/
Dst_Alpha,
/**
* RGB Factor (1-A_d, 1-A_d, 1-A_d), Alpha Factor (1-A_d)
*/
One_Minus_Dst_Alpha,
/**
* RGB Factor (i, i, i), Alpha Factor (1)
*/
Src_Alpha_Saturate;
}
/**
* BlendMode specifies the blending operation to use.
*
* @see RenderState#setBlendMode(com.jme3.material.RenderState.BlendMode)
*/
public enum BlendMode {
/**
* No blending mode is used.
*/
Off,
/**
* Additive blending. For use with glows and particle emitters.
*
* Result = Source Color + Destination Color -> (GL_ONE, GL_ONE)
*/
Additive,
/**
* Premultiplied alpha blending, for use with premult alpha textures.
*
* Result = Source Color + (Dest Color * (1 - Source Alpha) ) -> (GL_ONE, GL_ONE_MINUS_SRC_ALPHA)
*/
PremultAlpha,
/**
* Additive blending that is multiplied with source alpha.
* For use with glows and particle emitters.
*
* Result = (Source Alpha * Source Color) + Dest Color -> (GL_SRC_ALPHA, GL_ONE)
*/
AlphaAdditive,
/**
* Color blending, blends in color from dest color
* using source color.
*
* Result = Source Color + (1 - Source Color) * Dest Color -> (GL_ONE, GL_ONE_MINUS_SRC_COLOR)
*/
Color,
/**
* Alpha blending, interpolates to source color from dest color
* using source alpha.
*
* Result = Source Alpha * Source Color +
* (1 - Source Alpha) * Dest Color -> (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
*/
Alpha,
/**
* Alpha blending, interpolates to source color from dest color
* using source alpha.
* The resulting alpha is the sum between the source alpha and the destination alpha.
*
* Result.rgb = Source Alpha * Source Color +
* (1 - Source Alpha) * Dest Color -> (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
* Result.a = 1 * Source Alpha + 1 * Dest Alpha -> (GL_ONE, GL_ONE)
*/
AlphaSumA,
/**
* Multiplies the source and dest colors.
*
* Result = Source Color * Dest Color -> (GL_DST_COLOR, GL_ZERO)
*/
Modulate,
/**
* Multiplies the source and dest colors then doubles the result.
*
* Result = 2 * Source Color * Dest Color -> (GL_DST_COLOR, GL_SRC_COLOR)
*/
ModulateX2,
/**
* Opposite effect of Modulate/Multiply. Invert both colors, multiply and
* then invert the result.
*
* Result = 1 - (1 - Source Color) * (1 - Dest Color) -> (GL_ONE, GL_ONE_MINUS_SRC_COLOR)
*/
Screen,
/**
* Mixes the destination and source colors similar to a color-based XOR
* operation. This is directly equivalent to Photoshop's "Exclusion" blend.
*
* Result = (Source Color * (1 - Dest Color)) + (Dest Color * (1 - Source Color))
* -> (GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR)
*/
Exclusion,
/**
* Uses the blend equations and blend factors defined by the render state.
*
* These attributes can be set by using the following methods:
*
* - {@link RenderState#setBlendEquation(BlendEquation)}
*
- {@link RenderState#setBlendEquationAlpha(BlendEquationAlpha)}
*
- {@link RenderState#setCustomBlendFactors(BlendFunc, BlendFunc, BlendFunc, BlendFunc)}
*
*
* Result.RGB = BlendEquation( sfactorRGB * Source.RGB , dfactorRGB * Destination.RGB )
* Result.A = BlendEquationAlpha( sfactorAlpha * Source.A , dfactorAlpha * Destination.A )
*/
Custom
}
/**
* FaceCullMode specifies the criteria for faces to be culled.
*
* @see RenderState#setFaceCullMode(com.jme3.material.RenderState.FaceCullMode)
*/
public enum FaceCullMode {
/**
* Face culling is disabled.
*/
Off,
/**
* Cull front faces
*/
Front,
/**
* Cull back faces
*/
Back,
/**
* Cull both front and back faces.
*/
FrontAndBack
}
/**
* StencilOperation specifies the stencil operation to use
* in a certain scenario as specified in {@link RenderState#setStencil(boolean,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.TestFunction,
* com.jme3.material.RenderState.TestFunction) }
*/
public enum StencilOperation {
/**
* Keep the current value.
*/
Keep,
/**
* Set the value to 0
*/
Zero,
/**
* Replace the value in the stencil buffer with the reference value.
*/
Replace,
/**
* Increment the value in the stencil buffer, clamp once reaching
* the maximum value.
*/
Increment,
/**
* Increment the value in the stencil buffer and wrap to 0 when
* reaching the maximum value.
*/
IncrementWrap,
/**
* Decrement the value in the stencil buffer and clamp once reaching 0.
*/
Decrement,
/**
* Decrement the value in the stencil buffer and wrap to the maximum
* value when reaching 0.
*/
DecrementWrap,
/**
* Does a bitwise invert of the value in the stencil buffer.
*/
Invert
}
static {
NULL.cullMode = FaceCullMode.Off;
NULL.depthTest = false;
}
static {
ADDITIONAL.applyWireFrame = false;
ADDITIONAL.applyCullMode = false;
ADDITIONAL.applyDepthWrite = false;
ADDITIONAL.applyDepthTest = false;
ADDITIONAL.applyColorWrite = false;
ADDITIONAL.applyBlendMode = false;
ADDITIONAL.applyPolyOffset = false;
}
boolean wireframe = false;
boolean applyWireFrame = true;
FaceCullMode cullMode = FaceCullMode.Back;
boolean applyCullMode = true;
boolean depthWrite = true;
boolean applyDepthWrite = true;
boolean depthTest = true;
boolean applyDepthTest = true;
boolean colorWrite = true;
boolean applyColorWrite = true;
BlendEquation blendEquation = BlendEquation.Add;
BlendEquationAlpha blendEquationAlpha = BlendEquationAlpha.InheritColor;
BlendMode blendMode = BlendMode.Off;
boolean applyBlendMode = true;
float offsetFactor = 0;
float offsetUnits = 0;
boolean offsetEnabled = false;
boolean applyPolyOffset = true;
boolean stencilTest = false;
boolean applyStencilTest = false;
float lineWidth = 1;
boolean applyLineWidth = false;
TestFunction depthFunc = TestFunction.LessOrEqual;
//by default depth func will be applied anyway if depth test is applied
boolean applyDepthFunc = false;
StencilOperation frontStencilStencilFailOperation = StencilOperation.Keep;
StencilOperation frontStencilDepthFailOperation = StencilOperation.Keep;
StencilOperation frontStencilDepthPassOperation = StencilOperation.Keep;
StencilOperation backStencilStencilFailOperation = StencilOperation.Keep;
StencilOperation backStencilDepthFailOperation = StencilOperation.Keep;
StencilOperation backStencilDepthPassOperation = StencilOperation.Keep;
TestFunction frontStencilFunction = TestFunction.Always;
TestFunction backStencilFunction = TestFunction.Always;
int frontStencilReference = 0;
int backStencilReference = 0;
int frontStencilMask = Integer.MAX_VALUE;
int backStencilMask = Integer.MAX_VALUE;
int cachedHashCode = -1;
BlendFunc sfactorRGB = BlendFunc.One;
BlendFunc dfactorRGB = BlendFunc.One;
BlendFunc sfactorAlpha = BlendFunc.One;
BlendFunc dfactorAlpha = BlendFunc.One;
@Override
public void write(JmeExporter ex) throws IOException {
OutputCapsule oc = ex.getCapsule(this);
oc.write(true, "pointSprite", false);
oc.write(wireframe, "wireframe", false);
oc.write(cullMode, "cullMode", FaceCullMode.Back);
oc.write(depthWrite, "depthWrite", true);
oc.write(depthTest, "depthTest", true);
oc.write(colorWrite, "colorWrite", true);
oc.write(blendMode, "blendMode", BlendMode.Off);
oc.write(offsetEnabled, "offsetEnabled", false);
oc.write(offsetFactor, "offsetFactor", 0);
oc.write(offsetUnits, "offsetUnits", 0);
oc.write(stencilTest, "stencilTest", false);
oc.write(frontStencilStencilFailOperation, "frontStencilStencilFailOperation", StencilOperation.Keep);
oc.write(frontStencilDepthFailOperation, "frontStencilDepthFailOperation", StencilOperation.Keep);
oc.write(frontStencilDepthPassOperation, "frontStencilDepthPassOperation", StencilOperation.Keep);
oc.write(backStencilStencilFailOperation, "backStencilStencilFailOperation", StencilOperation.Keep);
oc.write(backStencilDepthFailOperation, "backStencilDepthFailOperation", StencilOperation.Keep);
oc.write(backStencilDepthPassOperation, "backStencilDepthPassOperation", StencilOperation.Keep);
oc.write(frontStencilFunction, "frontStencilFunction", TestFunction.Always);
oc.write(backStencilFunction, "backStencilFunction", TestFunction.Always);
oc.write(frontStencilReference, "frontStencilReference", 0);
oc.write(backStencilReference, "backStencilReference", 0);
oc.write(frontStencilMask, "frontStencilMask", Integer.MAX_VALUE);
oc.write(backStencilMask, "backStencilMask", Integer.MAX_VALUE);
oc.write(blendEquation, "blendEquation", BlendEquation.Add);
oc.write(blendEquationAlpha, "blendEquationAlpha", BlendEquationAlpha.InheritColor);
oc.write(depthFunc, "depthFunc", TestFunction.LessOrEqual);
oc.write(lineWidth, "lineWidth", 1);
oc.write(sfactorRGB, "sfactorRGB", BlendFunc.One);
oc.write(dfactorRGB, "dfactorRGB", BlendFunc.One);
oc.write(sfactorAlpha, "sfactorAlpha", BlendFunc.One);
oc.write(dfactorAlpha, "dfactorAlpha", BlendFunc.One);
// Only "additional render state" has them set to false by default
oc.write(applyWireFrame, "applyWireFrame", true);
oc.write(applyCullMode, "applyCullMode", true);
oc.write(applyDepthWrite, "applyDepthWrite", true);
oc.write(applyDepthTest, "applyDepthTest", true);
oc.write(applyColorWrite, "applyColorWrite", true);
oc.write(applyBlendMode, "applyBlendMode", true);
oc.write(applyPolyOffset, "applyPolyOffset", true);
oc.write(applyDepthFunc, "applyDepthFunc", true);
oc.write(applyLineWidth, "applyLineWidth", true);
}
@Override
public void read(JmeImporter im) throws IOException {
InputCapsule ic = im.getCapsule(this);
wireframe = ic.readBoolean("wireframe", false);
cullMode = ic.readEnum("cullMode", FaceCullMode.class, FaceCullMode.Back);
depthWrite = ic.readBoolean("depthWrite", true);
depthTest = ic.readBoolean("depthTest", true);
colorWrite = ic.readBoolean("colorWrite", true);
blendMode = ic.readEnum("blendMode", BlendMode.class, BlendMode.Off);
offsetEnabled = ic.readBoolean("offsetEnabled", false);
offsetFactor = ic.readFloat("offsetFactor", 0);
offsetUnits = ic.readFloat("offsetUnits", 0);
stencilTest = ic.readBoolean("stencilTest", false);
frontStencilStencilFailOperation = ic.readEnum("frontStencilStencilFailOperation", StencilOperation.class, StencilOperation.Keep);
frontStencilDepthFailOperation = ic.readEnum("frontStencilDepthFailOperation", StencilOperation.class, StencilOperation.Keep);
frontStencilDepthPassOperation = ic.readEnum("frontStencilDepthPassOperation", StencilOperation.class, StencilOperation.Keep);
backStencilStencilFailOperation = ic.readEnum("backStencilStencilFailOperation", StencilOperation.class, StencilOperation.Keep);
backStencilDepthFailOperation = ic.readEnum("backStencilDepthFailOperation", StencilOperation.class, StencilOperation.Keep);
backStencilDepthPassOperation = ic.readEnum("backStencilDepthPassOperation", StencilOperation.class, StencilOperation.Keep);
frontStencilFunction = ic.readEnum("frontStencilFunction", TestFunction.class, TestFunction.Always);
backStencilFunction = ic.readEnum("backStencilFunction", TestFunction.class, TestFunction.Always);
frontStencilReference = ic.readInt("frontStencilReference", 0);
backStencilReference = ic.readInt("backStencilReference", 0);
frontStencilMask = ic.readInt("frontStencilMask", Integer.MAX_VALUE);
backStencilMask = ic.readInt("backStencilMask", Integer.MAX_VALUE);
blendEquation = ic.readEnum("blendEquation", BlendEquation.class, BlendEquation.Add);
blendEquationAlpha = ic.readEnum("blendEquationAlpha", BlendEquationAlpha.class, BlendEquationAlpha.InheritColor);
depthFunc = ic.readEnum("depthFunc", TestFunction.class, TestFunction.LessOrEqual);
lineWidth = ic.readFloat("lineWidth", 1);
sfactorRGB = ic.readEnum("sfactorRGB", BlendFunc.class, BlendFunc.One);
dfactorRGB = ic.readEnum("dfactorRGB", BlendFunc.class, BlendFunc.One);
sfactorAlpha = ic.readEnum("sfactorAlpha", BlendFunc.class, BlendFunc.One);
dfactorAlpha = ic.readEnum("dfactorAlpha", BlendFunc.class, BlendFunc.One);
applyWireFrame = ic.readBoolean("applyWireFrame", true);
applyCullMode = ic.readBoolean("applyCullMode", true);
applyDepthWrite = ic.readBoolean("applyDepthWrite", true);
applyDepthTest = ic.readBoolean("applyDepthTest", true);
applyColorWrite = ic.readBoolean("applyColorWrite", true);
applyBlendMode = ic.readBoolean("applyBlendMode", true);
applyPolyOffset = ic.readBoolean("applyPolyOffset", true);
applyDepthFunc = ic.readBoolean("applyDepthFunc", true);
applyLineWidth = ic.readBoolean("applyLineWidth", true);
}
/**
* Create a clone of this RenderState
*
* @return Clone of this render state.
*/
@Override
public RenderState clone() {
try {
return (RenderState) super.clone();
} catch (CloneNotSupportedException ex) {
throw new AssertionError();
}
}
/**
* Tests for equivalence with the argument. If {@code o} is null, false is
* returned. Either way, the current instance is unaffected.
*
* @param o the object to compare (may be null, unaffected)
* @return true if {@code this} and {@code o} are equivalent,
* otherwise false
*/
@Override
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (!(o instanceof RenderState)) {
return false;
}
RenderState rs = (RenderState) o;
if (wireframe != rs.wireframe) {
return false;
}
if (cullMode != rs.cullMode) {
return false;
}
if (depthWrite != rs.depthWrite) {
return false;
}
if (depthTest != rs.depthTest) {
return false;
}
if (depthTest) {
if (depthFunc != rs.depthFunc) {
return false;
}
}
if (colorWrite != rs.colorWrite) {
return false;
}
if (blendMode != rs.blendMode) {
return false;
}
if (blendMode == BlendMode.Custom) {
if (blendEquation != rs.blendEquation) {
return false;
}
if (blendEquationAlpha != rs.blendEquationAlpha) {
return false;
}
if (sfactorRGB != rs.sfactorRGB) {
return false;
}
if (dfactorRGB != rs.dfactorRGB) {
return false;
}
if (sfactorAlpha != rs.sfactorAlpha) {
return false;
}
if (dfactorAlpha != rs.dfactorAlpha) {
return false;
}
}
if (offsetEnabled != rs.offsetEnabled) {
return false;
}
if (offsetFactor != rs.offsetFactor) {
return false;
}
if (offsetUnits != rs.offsetUnits) {
return false;
}
if (stencilTest != rs.stencilTest) {
return false;
}
if (stencilTest) {
if (frontStencilStencilFailOperation != rs.frontStencilStencilFailOperation) {
return false;
}
if (frontStencilDepthFailOperation != rs.frontStencilDepthFailOperation) {
return false;
}
if (frontStencilDepthPassOperation != rs.frontStencilDepthPassOperation) {
return false;
}
if (backStencilStencilFailOperation != rs.backStencilStencilFailOperation) {
return false;
}
if (backStencilDepthFailOperation != rs.backStencilDepthFailOperation) {
return false;
}
if (backStencilDepthPassOperation != rs.backStencilDepthPassOperation) {
return false;
}
if (frontStencilFunction != rs.frontStencilFunction) {
return false;
}
if (backStencilFunction != rs.backStencilFunction) {
return false;
}
if (frontStencilMask != rs.frontStencilMask) {
return false;
}
if (backStencilMask != rs.backStencilMask) {
return false;
}
if (frontStencilReference != rs.frontStencilReference) {
return false;
}
if (backStencilReference != rs.backStencilReference) {
return false;
}
}
if(lineWidth != rs.lineWidth){
return false;
}
return true;
}
/**
* Enable writing color.
*
*
When color write is enabled, the result of a fragment shader, the
* gl_FragColor, will be rendered into the color buffer
* (including alpha).
*
* @param colorWrite Set to true to enable color writing.
*/
public void setColorWrite(boolean colorWrite) {
applyColorWrite = true;
this.colorWrite = colorWrite;
cachedHashCode = -1;
}
/**
* Set the face culling mode.
*
*
See the {@link FaceCullMode} enum on what each value does.
* Face culling will project the triangle's points onto the screen
* and determine if the triangle is in counter-clockwise order or
* clockwise order. If a triangle is in counter-clockwise order, then
* it is considered a front-facing triangle, otherwise, it is considered
* a back-facing triangle.
*
* @param cullMode the face culling mode.
*/
public void setFaceCullMode(FaceCullMode cullMode) {
applyCullMode = true;
this.cullMode = cullMode;
cachedHashCode = -1;
}
/**
* Set the blending mode.
*
*
When blending is enabled, (blendMode is not {@link BlendMode#Off})
* the input pixel will be blended with the pixel
* already in the color buffer. The blending operation is determined
* by the {@link BlendMode}. For example, the {@link BlendMode#Additive}
* will add the input pixel's color to the color already in the color buffer:
*
* Result = Source Color + Destination Color
*
* @param blendMode The blend mode to use. Set to {@link BlendMode#Off}
* to disable blending.
*/
public void setBlendMode(BlendMode blendMode) {
applyBlendMode = true;
this.blendMode = blendMode;
cachedHashCode = -1;
}
/**
* Set the blending equation for the color component (RGB).
*
* The blending equation determines, how the RGB values of the input pixel
* will be blended with the RGB values of the pixel already in the color buffer.
* For example, {@link BlendEquation#Add} will add the input pixel's color
* to the color already in the color buffer:
*
* Result = Source Color + Destination Color
*
* Note: This gets only used in {@link BlendMode#Custom} mode.
* All other blend modes will ignore this setting.
*
* @param blendEquation The {@link BlendEquation} to use.
*/
public void setBlendEquation(BlendEquation blendEquation) {
this.blendEquation = blendEquation;
cachedHashCode = -1;
}
/**
* Set the blending equation for the alpha component.
*
* The alpha blending equation determines, how the alpha values of the input pixel
* will be blended with the alpha values of the pixel already in the color buffer.
* For example, {@link BlendEquationAlpha#Add} will add the input pixel's color
* to the color already in the color buffer:
*
* Result = Source Color + Destination Color
*
* Note: This gets only used in {@link BlendMode#Custom} mode.
* All other blend modes will ignore this setting.
*
* @param blendEquationAlpha The {@link BlendEquationAlpha} to use.
*/
public void setBlendEquationAlpha(BlendEquationAlpha blendEquationAlpha) {
this.blendEquationAlpha = blendEquationAlpha;
cachedHashCode = -1;
}
/**
* Sets the blend factors used for the source and destination color.
*
* These factors will be multiplied with the color values of the input pixel
* and the pixel already in the color buffer, before both colors gets combined by the {@link BlendEquation}.
*
* Note: This gets only used in {@link BlendMode#Custom} mode.
* All other blend modes will ignore this setting.
*
* @param sfactorRGB The source blend factor for RGB components.
* @param dfactorRGB The destination blend factor for RGB components.
* @param sfactorAlpha The source blend factor for the alpha component.
* @param dfactorAlpha The destination blend factor for the alpha component.
*/
public void setCustomBlendFactors(BlendFunc sfactorRGB, BlendFunc dfactorRGB, BlendFunc sfactorAlpha, BlendFunc dfactorAlpha) {
this.sfactorRGB = sfactorRGB;
this.dfactorRGB = dfactorRGB;
this.sfactorAlpha = sfactorAlpha;
this.dfactorAlpha = dfactorAlpha;
cachedHashCode = -1;
}
/**
* Enable depth testing.
*
*
When depth testing is enabled, a pixel must pass the depth test
* before it is written to the color buffer.
* The input pixel's depth value must be less than or equal than
* the value already in the depth buffer to pass the depth test.
*
* @param depthTest Enable or disable depth testing.
*/
public void setDepthTest(boolean depthTest) {
applyDepthTest = true;
this.depthTest = depthTest;
cachedHashCode = -1;
}
/**
* Enable depth writing.
*
*
After passing the {@link RenderState#setDepthTest(boolean) depth test},
* a pixel's depth value will be written into the depth buffer if
* depth writing is enabled.
*
* @param depthWrite True to enable writing to the depth buffer.
*/
public void setDepthWrite(boolean depthWrite) {
applyDepthWrite = true;
this.depthWrite = depthWrite;
cachedHashCode = -1;
}
/**
* Enables wireframe rendering mode.
*
*
When in wireframe mode, {@link Mesh meshes} rendered in triangle mode
* will not be solid, but instead, only the edges of the triangles
* will be rendered.
*
* @param wireframe True to enable wireframe mode.
*/
public void setWireframe(boolean wireframe) {
applyWireFrame = true;
this.wireframe = wireframe;
cachedHashCode = -1;
}
/**
* Offsets the on-screen z-order of the material's polygons, to combat visual artefacts like
* stitching, bleeding and z-fighting for overlapping polygons.
* Factor and units are summed to produce the depth offset.
* This offset is applied in screen space,
* typically with positive Z pointing into the screen.
* Typical values are (1.0f, 1.0f) or (-1.0f, -1.0f)
*
* @see http://www.opengl.org/resources/faq/technical/polygonoffset.htm
* @param factor scales the maximum Z slope, with respect to X or Y of the polygon
* @param units scales the minimum resolvable depth buffer value
*/
public void setPolyOffset(float factor, float units) {
applyPolyOffset = true;
if (factor == 0 && units == 0) {
offsetEnabled = false;
} else {
offsetEnabled = true;
offsetFactor = factor;
offsetUnits = units;
}
cachedHashCode = -1;
}
/**
* Enable stencil testing.
*
*
Stencil testing can be used to filter pixels according to the stencil
* buffer. Objects can be rendered with some stencil operation to manipulate
* the values in the stencil buffer, then, other objects can be rendered
* to test against the values written previously.
*
* @param enabled Set to true to enable stencil functionality. If false
* all other parameters are ignored.
*
* @param _frontStencilStencilFailOperation Sets the operation to occur when
* a front-facing triangle fails the front stencil function.
* @param _frontStencilDepthFailOperation Sets the operation to occur when
* a front-facing triangle fails the depth test.
* @param _frontStencilDepthPassOperation Set the operation to occur when
* a front-facing triangle passes the depth test.
* @param _backStencilStencilFailOperation Set the operation to occur when
* a back-facing triangle fails the back stencil function.
* @param _backStencilDepthFailOperation Set the operation to occur when
* a back-facing triangle fails the depth test.
* @param _backStencilDepthPassOperation Set the operation to occur when
* a back-facing triangle passes the depth test.
* @param _frontStencilFunction Set the test function for front-facing triangles.
* @param _backStencilFunction Set the test function for back-facing triangles.
*/
public void setStencil(boolean enabled,
StencilOperation _frontStencilStencilFailOperation,
StencilOperation _frontStencilDepthFailOperation,
StencilOperation _frontStencilDepthPassOperation,
StencilOperation _backStencilStencilFailOperation,
StencilOperation _backStencilDepthFailOperation,
StencilOperation _backStencilDepthPassOperation,
TestFunction _frontStencilFunction,
TestFunction _backStencilFunction) {
stencilTest = enabled;
applyStencilTest = true;
this.frontStencilStencilFailOperation = _frontStencilStencilFailOperation;
this.frontStencilDepthFailOperation = _frontStencilDepthFailOperation;
this.frontStencilDepthPassOperation = _frontStencilDepthPassOperation;
this.backStencilStencilFailOperation = _backStencilStencilFailOperation;
this.backStencilDepthFailOperation = _backStencilDepthFailOperation;
this.backStencilDepthPassOperation = _backStencilDepthPassOperation;
this.frontStencilFunction = _frontStencilFunction;
this.backStencilFunction = _backStencilFunction;
cachedHashCode = -1;
}
/**
* Set the depth comparison function to the given TestFunction
* default is LessOrEqual (GL_LEQUAL)
*
* @see TestFunction
* @see RenderState#setDepthTest(boolean)
* @param depthFunc the depth comparison function
*/
public void setDepthFunc(TestFunction depthFunc) {
applyDepthFunc = true;
this.depthFunc = depthFunc;
cachedHashCode = -1;
}
/**
* Sets the mesh line width.
* Use this in conjunction with {@link #setWireframe(boolean)} or with a mesh in
* {@link com.jme3.scene.Mesh.Mode#Lines} mode.
* Note: this does not work in OpenGL core profile. It only works in
* compatibility profile.
*
* @param lineWidth the line width.
*/
public void setLineWidth(float lineWidth) {
if (lineWidth < 1f) {
throw new IllegalArgumentException("lineWidth must be greater than or equal to 1.0");
}
this.lineWidth = lineWidth;
this.applyLineWidth = true;
cachedHashCode = -1;
}
/**
* Check if stencil test is enabled.
*
* @return True if stencil test is enabled.
*/
public boolean isStencilTest() {
return stencilTest;
}
/**
* Retrieve the front stencil fail operation.
*
* @return the front stencil fail operation.
*
* @see RenderState#setStencil(boolean,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.TestFunction,
* com.jme3.material.RenderState.TestFunction)
*/
public StencilOperation getFrontStencilStencilFailOperation() {
return frontStencilStencilFailOperation;
}
/**
* Retrieve the front depth test fail operation.
*
* @return the front depth test fail operation.
*
* @see RenderState#setStencil(boolean,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.TestFunction,
* com.jme3.material.RenderState.TestFunction)
*/
public StencilOperation getFrontStencilDepthFailOperation() {
return frontStencilDepthFailOperation;
}
/**
* Retrieve the front depth test pass operation.
*
* @return the front depth test pass operation.
*
* @see RenderState#setStencil(boolean,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.TestFunction,
* com.jme3.material.RenderState.TestFunction)
*/
public StencilOperation getFrontStencilDepthPassOperation() {
return frontStencilDepthPassOperation;
}
/**
* Retrieve the back stencil fail operation.
*
* @return the back stencil fail operation.
*
* @see RenderState#setStencil(boolean,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.TestFunction,
* com.jme3.material.RenderState.TestFunction)
*/
public StencilOperation getBackStencilStencilFailOperation() {
return backStencilStencilFailOperation;
}
/**
* Retrieve the back depth test fail operation.
*
* @return the back depth test fail operation.
*
* @see RenderState#setStencil(boolean,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.TestFunction,
* com.jme3.material.RenderState.TestFunction)
*/
public StencilOperation getBackStencilDepthFailOperation() {
return backStencilDepthFailOperation;
}
/**
* Retrieve the back depth test pass operation.
*
* @return the back depth test pass operation.
*
* @see RenderState#setStencil(boolean,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.TestFunction,
* com.jme3.material.RenderState.TestFunction)
*/
public StencilOperation getBackStencilDepthPassOperation() {
return backStencilDepthPassOperation;
}
/**
* Retrieve the front stencil function.
*
* @return the front stencil function.
*
* @see RenderState#setStencil(boolean,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.TestFunction,
* com.jme3.material.RenderState.TestFunction)
*/
public TestFunction getFrontStencilFunction() {
return frontStencilFunction;
}
/**
* Retrieve the back stencil function.
*
* @return the back stencil function.
*
* @see RenderState#setStencil(boolean,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.StencilOperation,
* com.jme3.material.RenderState.TestFunction,
* com.jme3.material.RenderState.TestFunction)
*/
public TestFunction getBackStencilFunction() {
return backStencilFunction;
}
/**
* Sets the front stencil mask.
*
* @param frontStencilMask the desired bitmask (default=0x7fffffff)
*/
public void setFrontStencilMask(int frontStencilMask) {
this.frontStencilMask = frontStencilMask;
}
/**
* Sets the back stencil mask.
*
* @param backStencilMask the desired bitmask (default=0x7fffffff)
*/
public void setBackStencilMask(int backStencilMask) {
this.backStencilMask = backStencilMask;
}
/**
* Sets the front stencil reference.
*
* @param frontStencilReference the desired reference (default=0x0)
*/
public void setFrontStencilReference(int frontStencilReference) {
this.frontStencilReference = frontStencilReference;
}
/**
* Sets the back stencil reference.
*
* @param backStencilReference the desired bitmask (default=0x0)
*/
public void setBackStencilReference(int backStencilReference) {
this.backStencilReference = backStencilReference;
}
/**
* Returns the front stencil mask.
*
* @return the bitmask applied before comparing the front stencil to its
* reference value
*/
public int getFrontStencilMask() {
return frontStencilMask;
}
/**
* Returns the front stencil reference.
*
* @return the reference value for the front stencil
*/
public int getFrontStencilReference() {
return frontStencilReference;
}
/**
* Returns the back stencil mask.
*
* @return the bitmask applied before comparing the back stencil to its
* reference value
*/
public int getBackStencilMask() {
return backStencilMask;
}
/**
* Returns the back stencil reference.
*
* @return the reference value for the back stencil
*/
public int getBackStencilReference() {
return backStencilReference;
}
/**
* Returns the blend equation.
*
* @return the blend equation.
*/
public BlendEquation getBlendEquation() {
return blendEquation;
}
/**
* Returns the blend equation used for the alpha component.
*
* @return the blend equation for the alpha component.
*/
public BlendEquationAlpha getBlendEquationAlpha() {
return blendEquationAlpha;
}
/**
* Returns the blend mode.
*
* @return the blend mode.
*/
public BlendMode getBlendMode() {
return blendMode;
}
/**
* Returns the source factor for the RGB components in
* BlendMode.Custom.
*
* @return the custom source factor for RGB components.
*/
public BlendFunc getCustomSfactorRGB() {
return sfactorRGB;
}
/**
* Returns the destination factor for the RGB components in
* BlendMode.Custom.
*
* @return the custom destination factor for RGB components.
*/
public BlendFunc getCustomDfactorRGB() {
return dfactorRGB;
}
/**
* Returns the source factor for the alpha component in
* BlendMode.Custom.
*
* @return the custom destination factor for alpha component.
*/
public BlendFunc getCustomSfactorAlpha() {
return sfactorAlpha;
}
/**
* Returns the destination factor for the alpha component in
* BlendMode.Custom.
*
* @return the custom destination factor for alpha component.
*/
public BlendFunc getCustomDfactorAlpha() {
return dfactorAlpha;
}
/**
* @return true
* @deprecated Always returns true since point sprite is always enabled.
*/
@Deprecated
public boolean isPointSprite() {
return true;
}
/**
* @deprecated To use alpha test, set the AlphaDiscardThreshold
* material parameter.
* @return false
*/
@Deprecated
public boolean isAlphaTest() {
return false;
}
/**
* Retrieve the face cull mode.
*
* @return the face cull mode.
*
* @see RenderState#setFaceCullMode(com.jme3.material.RenderState.FaceCullMode)
*/
public FaceCullMode getFaceCullMode() {
return cullMode;
}
/**
* Check if depth test is enabled.
*
* @return True if depth test is enabled.
*
* @see RenderState#setDepthTest(boolean)
*/
public boolean isDepthTest() {
return depthTest;
}
/**
* Check if depth write is enabled.
*
* @return True if depth write is enabled.
*
* @see RenderState#setDepthWrite(boolean)
*/
public boolean isDepthWrite() {
return depthWrite;
}
/**
* Check if wireframe mode is enabled.
*
* @return True if wireframe mode is enabled.
*
* @see RenderState#setWireframe(boolean)
*/
public boolean isWireframe() {
return wireframe;
}
/**
* Check if color writing is enabled.
*
* @return True if color writing is enabled.
*
* @see RenderState#setColorWrite(boolean)
*/
public boolean isColorWrite() {
return colorWrite;
}
/**
* Retrieve the poly offset factor value.
*
* @return the poly offset factor value.
*
* @see RenderState#setPolyOffset(float, float)
*/
public float getPolyOffsetFactor() {
return offsetFactor;
}
/**
* Retrieve the poly offset units value.
*
* @return the poly offset units value.
*
* @see RenderState#setPolyOffset(float, float)
*/
public float getPolyOffsetUnits() {
return offsetUnits;
}
/**
* Check if polygon offset is enabled.
*
* @return True if polygon offset is enabled.
*
* @see RenderState#setPolyOffset(float, float)
*/
public boolean isPolyOffset() {
return offsetEnabled;
}
/**
* @return 0
* @deprecated
*/
@Deprecated
public float getAlphaFallOff() {
return 0f;
}
/**
* Retrieve the depth comparison function
*
* @return the depth comparison function
*
* @see RenderState#setDepthFunc(com.jme3.material.RenderState.TestFunction)
*/
public TestFunction getDepthFunc() {
return depthFunc;
}
/**
* @return {@link TestFunction#Greater}.
* @deprecated
*/
@Deprecated
public TestFunction getAlphaFunc() {
return TestFunction.Greater;
}
/**
* returns the wireframe line width
*
* @return the line width
*/
public float getLineWidth() {
return lineWidth;
}
public boolean isApplyBlendMode() {
return applyBlendMode;
}
public boolean isApplyColorWrite() {
return applyColorWrite;
}
public boolean isApplyCullMode() {
return applyCullMode;
}
public boolean isApplyDepthTest() {
return applyDepthTest;
}
public boolean isApplyDepthWrite() {
return applyDepthWrite;
}
public boolean isApplyPolyOffset() {
return applyPolyOffset;
}
public boolean isApplyWireFrame() {
return applyWireFrame;
}
public boolean isApplyDepthFunc() {
return applyDepthFunc;
}
public boolean isApplyLineWidth() {
return applyLineWidth;
}
/**
* @return value for use in hashing
*/
public int contentHashCode() {
if (cachedHashCode == -1){
int hash = 7;
hash = 79 * hash + (this.wireframe ? 1 : 0);
hash = 79 * hash + (this.cullMode != null ? this.cullMode.hashCode() : 0);
hash = 79 * hash + (this.depthWrite ? 1 : 0);
hash = 79 * hash + (this.depthTest ? 1 : 0);
hash = 79 * hash + (this.depthFunc != null ? this.depthFunc.hashCode() : 0);
hash = 79 * hash + (this.colorWrite ? 1 : 0);
hash = 79 * hash + (this.blendMode != null ? this.blendMode.hashCode() : 0);
hash = 79 * hash + (this.blendEquation != null ? this.blendEquation.hashCode() : 0);
hash = 79 * hash + (this.blendEquationAlpha != null ? this.blendEquationAlpha.hashCode() : 0);
hash = 79 * hash + Float.floatToIntBits(this.offsetFactor);
hash = 79 * hash + Float.floatToIntBits(this.offsetUnits);
hash = 79 * hash + (this.offsetEnabled ? 1 : 0);
hash = 79 * hash + (this.stencilTest ? 1 : 0);
hash = 79 * hash + (this.frontStencilStencilFailOperation != null ? this.frontStencilStencilFailOperation.hashCode() : 0);
hash = 79 * hash + (this.frontStencilDepthFailOperation != null ? this.frontStencilDepthFailOperation.hashCode() : 0);
hash = 79 * hash + (this.frontStencilDepthPassOperation != null ? this.frontStencilDepthPassOperation.hashCode() : 0);
hash = 79 * hash + (this.backStencilStencilFailOperation != null ? this.backStencilStencilFailOperation.hashCode() : 0);
hash = 79 * hash + (this.backStencilDepthFailOperation != null ? this.backStencilDepthFailOperation.hashCode() : 0);
hash = 79 * hash + (this.backStencilDepthPassOperation != null ? this.backStencilDepthPassOperation.hashCode() : 0);
hash = 79 * hash + (this.frontStencilFunction != null ? this.frontStencilFunction.hashCode() : 0);
hash = 79 * hash + (this.backStencilFunction != null ? this.backStencilFunction.hashCode() : 0);
hash = 79 * hash + Float.floatToIntBits(this.lineWidth);
hash = 79 * hash + this.sfactorRGB.hashCode();
hash = 79 * hash + this.dfactorRGB.hashCode();
hash = 79 * hash + this.sfactorAlpha.hashCode();
hash = 79 * hash + this.dfactorAlpha.hashCode();
cachedHashCode = hash;
}
return cachedHashCode;
}
/**
* Merges this state and additionalState into
* the parameter state based on a specific criteria.
*
*
The criteria for this merge is the following:
* For every given property, such as alpha test or depth write, check
* if it was modified from the original in the additionalState
* if it was modified, then copy the property from the additionalState
* into the parameter state, otherwise, copy the property from this
* into the parameter state. If additionalState
* is null, then no modifications are made and this is returned,
* otherwise, the parameter state is returned with the result
* of the merge.
*
* @param additionalState The additionalState, from which data is taken only
* if it was modified by the user.
* @param state Contains output of the method if additionalState
* is not null.
* @return state if additionalState is non-null,
* otherwise returns this
*/
public RenderState copyMergedTo(RenderState additionalState, RenderState state) {
if (additionalState == null) {
return this;
}
if (additionalState.applyWireFrame) {
state.wireframe = additionalState.wireframe;
} else {
state.wireframe = wireframe;
}
if (additionalState.applyCullMode) {
state.cullMode = additionalState.cullMode;
} else {
state.cullMode = cullMode;
}
if (additionalState.applyDepthWrite) {
state.depthWrite = additionalState.depthWrite;
} else {
state.depthWrite = depthWrite;
}
if (additionalState.applyDepthTest) {
state.depthTest = additionalState.depthTest;
} else {
state.depthTest = depthTest;
}
if (additionalState.applyDepthFunc) {
state.depthFunc = additionalState.depthFunc;
} else {
state.depthFunc = depthFunc;
}
if (additionalState.applyColorWrite) {
state.colorWrite = additionalState.colorWrite;
} else {
state.colorWrite = colorWrite;
}
if (additionalState.applyBlendMode) {
state.blendMode = additionalState.blendMode;
if (additionalState.blendMode == BlendMode.Custom) {
state.blendEquation = additionalState.blendEquation;
state.blendEquationAlpha = additionalState.blendEquationAlpha;
state.sfactorRGB = additionalState.sfactorRGB;
state.dfactorRGB = additionalState.dfactorRGB;
state.sfactorAlpha = additionalState.sfactorAlpha;
state.dfactorAlpha = additionalState.dfactorAlpha;
}
} else {
state.blendMode = blendMode;
if (blendMode == BlendMode.Custom) {
state.blendEquation = blendEquation;
state.blendEquationAlpha = blendEquationAlpha;
state.sfactorRGB = sfactorRGB;
state.dfactorRGB = dfactorRGB;
state.sfactorAlpha = sfactorAlpha;
state.dfactorAlpha = dfactorAlpha;
}
}
if (additionalState.applyPolyOffset) {
state.offsetEnabled = additionalState.offsetEnabled;
state.offsetFactor = additionalState.offsetFactor;
state.offsetUnits = additionalState.offsetUnits;
} else {
state.offsetEnabled = offsetEnabled;
state.offsetFactor = offsetFactor;
state.offsetUnits = offsetUnits;
}
if (additionalState.applyStencilTest) {
state.stencilTest = additionalState.stencilTest;
state.frontStencilStencilFailOperation = additionalState.frontStencilStencilFailOperation;
state.frontStencilDepthFailOperation = additionalState.frontStencilDepthFailOperation;
state.frontStencilDepthPassOperation = additionalState.frontStencilDepthPassOperation;
state.backStencilStencilFailOperation = additionalState.backStencilStencilFailOperation;
state.backStencilDepthFailOperation = additionalState.backStencilDepthFailOperation;
state.backStencilDepthPassOperation = additionalState.backStencilDepthPassOperation;
state.frontStencilFunction = additionalState.frontStencilFunction;
state.backStencilFunction = additionalState.backStencilFunction;
} else {
state.stencilTest = stencilTest;
state.frontStencilStencilFailOperation = frontStencilStencilFailOperation;
state.frontStencilDepthFailOperation = frontStencilDepthFailOperation;
state.frontStencilDepthPassOperation = frontStencilDepthPassOperation;
state.backStencilStencilFailOperation = backStencilStencilFailOperation;
state.backStencilDepthFailOperation = backStencilDepthFailOperation;
state.backStencilDepthPassOperation = backStencilDepthPassOperation;
state.frontStencilFunction = frontStencilFunction;
state.backStencilFunction = backStencilFunction;
}
if (additionalState.applyLineWidth) {
state.lineWidth = additionalState.lineWidth;
} else {
state.lineWidth = lineWidth;
}
state.cachedHashCode = -1;
return state;
}
public void set(RenderState state) {
wireframe = state.wireframe;
cullMode = state.cullMode;
depthWrite = state.depthWrite;
depthTest = state.depthTest;
colorWrite = state.colorWrite;
blendMode = state.blendMode;
offsetEnabled = state.offsetEnabled;
offsetFactor = state.offsetFactor;
offsetUnits = state.offsetUnits;
stencilTest = state.stencilTest;
frontStencilStencilFailOperation = state.frontStencilStencilFailOperation;
frontStencilDepthFailOperation = state.frontStencilDepthFailOperation;
frontStencilDepthPassOperation = state.frontStencilDepthPassOperation;
backStencilStencilFailOperation = state.backStencilStencilFailOperation;
backStencilDepthFailOperation = state.backStencilDepthFailOperation;
backStencilDepthPassOperation = state.backStencilDepthPassOperation;
frontStencilFunction = state.frontStencilFunction;
backStencilFunction = state.backStencilFunction;
blendEquationAlpha = state.blendEquationAlpha;
blendEquation = state.blendEquation;
depthFunc = state.depthFunc;
lineWidth = state.lineWidth;
applyWireFrame = true;
applyCullMode = true;
applyDepthWrite = true;
applyDepthTest = true;
applyColorWrite = true;
applyBlendMode = true;
applyPolyOffset = true;
applyDepthFunc = true;
applyLineWidth = true;
sfactorRGB = state.sfactorRGB;
dfactorRGB = state.dfactorRGB;
sfactorAlpha = state.sfactorAlpha;
dfactorAlpha = state.dfactorAlpha;
}
/**
* Copy all values from the given state to this state.
*
* This method is more precise than {@link #set(com.jme3.material.RenderState)}.
* @param state state to copy from
*/
public RenderState copyFrom(RenderState state) {
this.applyBlendMode = state.applyBlendMode;
this.applyColorWrite = state.applyColorWrite;
this.applyCullMode = state.applyCullMode;
this.applyDepthFunc = state.applyDepthFunc;
this.applyDepthTest = state.applyDepthTest;
this.applyDepthWrite = state.applyDepthWrite;
this.applyLineWidth = state.applyLineWidth;
this.applyPolyOffset = state.applyPolyOffset;
this.applyStencilTest = state.applyStencilTest;
this.applyWireFrame = state.applyWireFrame;
this.backStencilDepthFailOperation = state.backStencilDepthFailOperation;
this.backStencilDepthPassOperation = state.backStencilDepthPassOperation;
this.backStencilFunction = state.backStencilFunction;
this.backStencilMask = state.backStencilMask;
this.backStencilReference = state.backStencilReference;
this.backStencilStencilFailOperation = state.backStencilStencilFailOperation;
this.blendEquation = state.blendEquation;
this.blendEquationAlpha = state.blendEquationAlpha;
this.blendMode = state.blendMode;
this.cachedHashCode = state.cachedHashCode;
this.colorWrite = state.colorWrite;
this.cullMode = state.cullMode;
this.depthFunc = state.depthFunc;
this.depthTest = state.depthTest;
this.depthWrite = state.depthWrite;
this.dfactorAlpha = state.dfactorAlpha;
this.dfactorRGB = state.dfactorRGB;
this.frontStencilDepthFailOperation = state.frontStencilDepthFailOperation;
this.frontStencilDepthPassOperation = state.frontStencilDepthPassOperation;
this.frontStencilFunction = state.frontStencilFunction;
this.frontStencilMask = state.frontStencilMask;
this.frontStencilReference = state.frontStencilReference;
this.frontStencilStencilFailOperation = state.frontStencilStencilFailOperation;
this.lineWidth = state.lineWidth;
this.offsetEnabled = state.offsetEnabled;
this.offsetFactor = state.offsetFactor;
this.offsetUnits = state.offsetUnits;
this.sfactorAlpha = state.sfactorAlpha;
this.sfactorRGB = state.sfactorRGB;
this.stencilTest = state.stencilTest;
this.wireframe = state.wireframe;
return this;
}
@Override
public String toString() {
return "RenderState[\n"
+ "\nwireframe=" + wireframe
+ "\napplyWireFrame=" + applyWireFrame
+ "\ncullMode=" + cullMode
+ "\napplyCullMode=" + applyCullMode
+ "\ndepthWrite=" + depthWrite
+ "\napplyDepthWrite=" + applyDepthWrite
+ "\ndepthTest=" + depthTest
+ "\ndepthFunc=" + depthFunc
+ "\napplyDepthTest=" + applyDepthTest
+ "\ncolorWrite=" + colorWrite
+ "\napplyColorWrite=" + applyColorWrite
+ "\nblendEquation=" + blendEquation
+ "\nblendMode=" + blendMode
+ "\napplyBlendMode=" + applyBlendMode
+ "\noffsetEnabled=" + offsetEnabled
+ "\napplyPolyOffset=" + applyPolyOffset
+ "\noffsetFactor=" + offsetFactor
+ "\noffsetUnits=" + offsetUnits
+ "\nlineWidth=" + lineWidth
+ (blendMode.equals(BlendMode.Custom)? "\ncustomBlendFactors=("+sfactorRGB+", "+dfactorRGB+", "+sfactorAlpha+", "+dfactorAlpha+")":"")
+"\n]";
}
/**
* Flips the given face cull mode so that {@code Back} becomes
* {@code Front} and {@code Front} becomes {@code Back}.
*
{@code FrontAndBack} and {@code Off} are unaffected. This is important
* for flipping the cull mode when normal vectors are found to be backward.
*/
public void flipFaceCull() {
switch (cullMode) {
case Back: cullMode = FaceCullMode.Front; break;
case Front: cullMode = FaceCullMode.Back; break;
}
}
/**
* Checks if the face cull mode is "flippable".
*
The cull mode is flippable when it is either {@code Front} or {@code Back}.
* @return
*/
public boolean isFaceCullFlippable() {
return cullMode == FaceCullMode.Front || cullMode == FaceCullMode.Back;
}
}