import BoundingRectangle from '../Core/BoundingRectangle.js';
|
import Color from '../Core/Color.js';
|
import defaultValue from '../Core/defaultValue.js';
|
import defined from '../Core/defined.js';
|
import DeveloperError from '../Core/DeveloperError.js';
|
import WebGLConstants from '../Core/WebGLConstants.js';
|
import WindingOrder from '../Core/WindingOrder.js';
|
import ContextLimits from './ContextLimits.js';
|
import freezeRenderState from './freezeRenderState.js';
|
|
function validateBlendEquation(blendEquation) {
|
return ((blendEquation === WebGLConstants.FUNC_ADD) ||
|
(blendEquation === WebGLConstants.FUNC_SUBTRACT) ||
|
(blendEquation === WebGLConstants.FUNC_REVERSE_SUBTRACT) ||
|
(blendEquation === WebGLConstants.MIN) ||
|
(blendEquation === WebGLConstants.MAX));
|
}
|
|
function validateBlendFunction(blendFunction) {
|
return ((blendFunction === WebGLConstants.ZERO) ||
|
(blendFunction === WebGLConstants.ONE) ||
|
(blendFunction === WebGLConstants.SRC_COLOR) ||
|
(blendFunction === WebGLConstants.ONE_MINUS_SRC_COLOR) ||
|
(blendFunction === WebGLConstants.DST_COLOR) ||
|
(blendFunction === WebGLConstants.ONE_MINUS_DST_COLOR) ||
|
(blendFunction === WebGLConstants.SRC_ALPHA) ||
|
(blendFunction === WebGLConstants.ONE_MINUS_SRC_ALPHA) ||
|
(blendFunction === WebGLConstants.DST_ALPHA) ||
|
(blendFunction === WebGLConstants.ONE_MINUS_DST_ALPHA) ||
|
(blendFunction === WebGLConstants.CONSTANT_COLOR) ||
|
(blendFunction === WebGLConstants.ONE_MINUS_CONSTANT_COLOR) ||
|
(blendFunction === WebGLConstants.CONSTANT_ALPHA) ||
|
(blendFunction === WebGLConstants.ONE_MINUS_CONSTANT_ALPHA) ||
|
(blendFunction === WebGLConstants.SRC_ALPHA_SATURATE));
|
}
|
|
function validateCullFace(cullFace) {
|
return ((cullFace === WebGLConstants.FRONT) ||
|
(cullFace === WebGLConstants.BACK) ||
|
(cullFace === WebGLConstants.FRONT_AND_BACK));
|
}
|
|
function validateDepthFunction(depthFunction) {
|
return ((depthFunction === WebGLConstants.NEVER) ||
|
(depthFunction === WebGLConstants.LESS) ||
|
(depthFunction === WebGLConstants.EQUAL) ||
|
(depthFunction === WebGLConstants.LEQUAL) ||
|
(depthFunction === WebGLConstants.GREATER) ||
|
(depthFunction === WebGLConstants.NOTEQUAL) ||
|
(depthFunction === WebGLConstants.GEQUAL) ||
|
(depthFunction === WebGLConstants.ALWAYS));
|
}
|
|
function validateStencilFunction(stencilFunction) {
|
return ((stencilFunction === WebGLConstants.NEVER) ||
|
(stencilFunction === WebGLConstants.LESS) ||
|
(stencilFunction === WebGLConstants.EQUAL) ||
|
(stencilFunction === WebGLConstants.LEQUAL) ||
|
(stencilFunction === WebGLConstants.GREATER) ||
|
(stencilFunction === WebGLConstants.NOTEQUAL) ||
|
(stencilFunction === WebGLConstants.GEQUAL) ||
|
(stencilFunction === WebGLConstants.ALWAYS));
|
}
|
|
function validateStencilOperation(stencilOperation) {
|
return ((stencilOperation === WebGLConstants.ZERO) ||
|
(stencilOperation === WebGLConstants.KEEP) ||
|
(stencilOperation === WebGLConstants.REPLACE) ||
|
(stencilOperation === WebGLConstants.INCR) ||
|
(stencilOperation === WebGLConstants.DECR) ||
|
(stencilOperation === WebGLConstants.INVERT) ||
|
(stencilOperation === WebGLConstants.INCR_WRAP) ||
|
(stencilOperation === WebGLConstants.DECR_WRAP));
|
}
|
|
/**
|
* @private
|
*/
|
function RenderState(renderState) {
|
var rs = defaultValue(renderState, defaultValue.EMPTY_OBJECT);
|
var cull = defaultValue(rs.cull, defaultValue.EMPTY_OBJECT);
|
var polygonOffset = defaultValue(rs.polygonOffset, defaultValue.EMPTY_OBJECT);
|
var scissorTest = defaultValue(rs.scissorTest, defaultValue.EMPTY_OBJECT);
|
var scissorTestRectangle = defaultValue(scissorTest.rectangle, defaultValue.EMPTY_OBJECT);
|
var depthRange = defaultValue(rs.depthRange, defaultValue.EMPTY_OBJECT);
|
var depthTest = defaultValue(rs.depthTest, defaultValue.EMPTY_OBJECT);
|
var colorMask = defaultValue(rs.colorMask, defaultValue.EMPTY_OBJECT);
|
var blending = defaultValue(rs.blending, defaultValue.EMPTY_OBJECT);
|
var blendingColor = defaultValue(blending.color, defaultValue.EMPTY_OBJECT);
|
var stencilTest = defaultValue(rs.stencilTest, defaultValue.EMPTY_OBJECT);
|
var stencilTestFrontOperation = defaultValue(stencilTest.frontOperation, defaultValue.EMPTY_OBJECT);
|
var stencilTestBackOperation = defaultValue(stencilTest.backOperation, defaultValue.EMPTY_OBJECT);
|
var sampleCoverage = defaultValue(rs.sampleCoverage, defaultValue.EMPTY_OBJECT);
|
var viewport = rs.viewport;
|
|
this.frontFace = defaultValue(rs.frontFace, WindingOrder.COUNTER_CLOCKWISE);
|
this.cull = {
|
enabled : defaultValue(cull.enabled, false),
|
face : defaultValue(cull.face, WebGLConstants.BACK)
|
};
|
this.lineWidth = defaultValue(rs.lineWidth, 1.0);
|
this.polygonOffset = {
|
enabled : defaultValue(polygonOffset.enabled, false),
|
factor : defaultValue(polygonOffset.factor, 0),
|
units : defaultValue(polygonOffset.units, 0)
|
};
|
this.scissorTest = {
|
enabled : defaultValue(scissorTest.enabled, false),
|
rectangle : BoundingRectangle.clone(scissorTestRectangle)
|
};
|
this.depthRange = {
|
near : defaultValue(depthRange.near, 0),
|
far : defaultValue(depthRange.far, 1)
|
};
|
this.depthTest = {
|
enabled : defaultValue(depthTest.enabled, false),
|
func : defaultValue(depthTest.func, WebGLConstants.LESS) // func, because function is a JavaScript keyword
|
};
|
this.colorMask = {
|
red : defaultValue(colorMask.red, true),
|
green : defaultValue(colorMask.green, true),
|
blue : defaultValue(colorMask.blue, true),
|
alpha : defaultValue(colorMask.alpha, true)
|
};
|
this.depthMask = defaultValue(rs.depthMask, true);
|
this.stencilMask = defaultValue(rs.stencilMask, ~0);
|
this.blending = {
|
enabled : defaultValue(blending.enabled, false),
|
color : new Color(
|
defaultValue(blendingColor.red, 0.0),
|
defaultValue(blendingColor.green, 0.0),
|
defaultValue(blendingColor.blue, 0.0),
|
defaultValue(blendingColor.alpha, 0.0)
|
),
|
equationRgb : defaultValue(blending.equationRgb, WebGLConstants.FUNC_ADD),
|
equationAlpha : defaultValue(blending.equationAlpha, WebGLConstants.FUNC_ADD),
|
functionSourceRgb : defaultValue(blending.functionSourceRgb, WebGLConstants.ONE),
|
functionSourceAlpha : defaultValue(blending.functionSourceAlpha, WebGLConstants.ONE),
|
functionDestinationRgb : defaultValue(blending.functionDestinationRgb, WebGLConstants.ZERO),
|
functionDestinationAlpha : defaultValue(blending.functionDestinationAlpha, WebGLConstants.ZERO)
|
};
|
this.stencilTest = {
|
enabled : defaultValue(stencilTest.enabled, false),
|
frontFunction : defaultValue(stencilTest.frontFunction, WebGLConstants.ALWAYS),
|
backFunction : defaultValue(stencilTest.backFunction, WebGLConstants.ALWAYS),
|
reference : defaultValue(stencilTest.reference, 0),
|
mask : defaultValue(stencilTest.mask, ~0),
|
frontOperation : {
|
fail : defaultValue(stencilTestFrontOperation.fail, WebGLConstants.KEEP),
|
zFail : defaultValue(stencilTestFrontOperation.zFail, WebGLConstants.KEEP),
|
zPass : defaultValue(stencilTestFrontOperation.zPass, WebGLConstants.KEEP)
|
},
|
backOperation : {
|
fail : defaultValue(stencilTestBackOperation.fail, WebGLConstants.KEEP),
|
zFail : defaultValue(stencilTestBackOperation.zFail, WebGLConstants.KEEP),
|
zPass : defaultValue(stencilTestBackOperation.zPass, WebGLConstants.KEEP)
|
}
|
};
|
this.sampleCoverage = {
|
enabled : defaultValue(sampleCoverage.enabled, false),
|
value : defaultValue(sampleCoverage.value, 1.0),
|
invert : defaultValue(sampleCoverage.invert, false)
|
};
|
this.viewport = (defined(viewport)) ? new BoundingRectangle(viewport.x, viewport.y, viewport.width, viewport.height) : undefined;
|
|
//>>includeStart('debug', pragmas.debug);
|
if ((this.lineWidth < ContextLimits.minimumAliasedLineWidth) ||
|
(this.lineWidth > ContextLimits.maximumAliasedLineWidth)) {
|
throw new DeveloperError('renderState.lineWidth is out of range. Check minimumAliasedLineWidth and maximumAliasedLineWidth.');
|
}
|
if (!WindingOrder.validate(this.frontFace)) {
|
throw new DeveloperError('Invalid renderState.frontFace.');
|
}
|
if (!validateCullFace(this.cull.face)) {
|
throw new DeveloperError('Invalid renderState.cull.face.');
|
}
|
if ((this.scissorTest.rectangle.width < 0) ||
|
(this.scissorTest.rectangle.height < 0)) {
|
throw new DeveloperError('renderState.scissorTest.rectangle.width and renderState.scissorTest.rectangle.height must be greater than or equal to zero.');
|
}
|
if (this.depthRange.near > this.depthRange.far) {
|
// WebGL specific - not an error in GL ES
|
throw new DeveloperError('renderState.depthRange.near can not be greater than renderState.depthRange.far.');
|
}
|
if (this.depthRange.near < 0) {
|
// Would be clamped by GL
|
throw new DeveloperError('renderState.depthRange.near must be greater than or equal to zero.');
|
}
|
if (this.depthRange.far > 1) {
|
// Would be clamped by GL
|
throw new DeveloperError('renderState.depthRange.far must be less than or equal to one.');
|
}
|
if (!validateDepthFunction(this.depthTest.func)) {
|
throw new DeveloperError('Invalid renderState.depthTest.func.');
|
}
|
if ((this.blending.color.red < 0.0) || (this.blending.color.red > 1.0) ||
|
(this.blending.color.green < 0.0) || (this.blending.color.green > 1.0) ||
|
(this.blending.color.blue < 0.0) || (this.blending.color.blue > 1.0) ||
|
(this.blending.color.alpha < 0.0) || (this.blending.color.alpha > 1.0)) {
|
// Would be clamped by GL
|
throw new DeveloperError('renderState.blending.color components must be greater than or equal to zero and less than or equal to one.');
|
}
|
if (!validateBlendEquation(this.blending.equationRgb)) {
|
throw new DeveloperError('Invalid renderState.blending.equationRgb.');
|
}
|
if (!validateBlendEquation(this.blending.equationAlpha)) {
|
throw new DeveloperError('Invalid renderState.blending.equationAlpha.');
|
}
|
if (!validateBlendFunction(this.blending.functionSourceRgb)) {
|
throw new DeveloperError('Invalid renderState.blending.functionSourceRgb.');
|
}
|
if (!validateBlendFunction(this.blending.functionSourceAlpha)) {
|
throw new DeveloperError('Invalid renderState.blending.functionSourceAlpha.');
|
}
|
if (!validateBlendFunction(this.blending.functionDestinationRgb)) {
|
throw new DeveloperError('Invalid renderState.blending.functionDestinationRgb.');
|
}
|
if (!validateBlendFunction(this.blending.functionDestinationAlpha)) {
|
throw new DeveloperError('Invalid renderState.blending.functionDestinationAlpha.');
|
}
|
if (!validateStencilFunction(this.stencilTest.frontFunction)) {
|
throw new DeveloperError('Invalid renderState.stencilTest.frontFunction.');
|
}
|
if (!validateStencilFunction(this.stencilTest.backFunction)) {
|
throw new DeveloperError('Invalid renderState.stencilTest.backFunction.');
|
}
|
if (!validateStencilOperation(this.stencilTest.frontOperation.fail)) {
|
throw new DeveloperError('Invalid renderState.stencilTest.frontOperation.fail.');
|
}
|
if (!validateStencilOperation(this.stencilTest.frontOperation.zFail)) {
|
throw new DeveloperError('Invalid renderState.stencilTest.frontOperation.zFail.');
|
}
|
if (!validateStencilOperation(this.stencilTest.frontOperation.zPass)) {
|
throw new DeveloperError('Invalid renderState.stencilTest.frontOperation.zPass.');
|
}
|
if (!validateStencilOperation(this.stencilTest.backOperation.fail)) {
|
throw new DeveloperError('Invalid renderState.stencilTest.backOperation.fail.');
|
}
|
if (!validateStencilOperation(this.stencilTest.backOperation.zFail)) {
|
throw new DeveloperError('Invalid renderState.stencilTest.backOperation.zFail.');
|
}
|
if (!validateStencilOperation(this.stencilTest.backOperation.zPass)) {
|
throw new DeveloperError('Invalid renderState.stencilTest.backOperation.zPass.');
|
}
|
|
if (defined(this.viewport)) {
|
if (this.viewport.width < 0) {
|
throw new DeveloperError('renderState.viewport.width must be greater than or equal to zero.');
|
}
|
if (this.viewport.height < 0) {
|
throw new DeveloperError('renderState.viewport.height must be greater than or equal to zero.');
|
}
|
|
if (this.viewport.width > ContextLimits.maximumViewportWidth) {
|
throw new DeveloperError('renderState.viewport.width must be less than or equal to the maximum viewport width (' + ContextLimits.maximumViewportWidth.toString() + '). Check maximumViewportWidth.');
|
}
|
if (this.viewport.height > ContextLimits.maximumViewportHeight) {
|
throw new DeveloperError('renderState.viewport.height must be less than or equal to the maximum viewport height (' + ContextLimits.maximumViewportHeight.toString() + '). Check maximumViewportHeight.');
|
}
|
}
|
//>>includeEnd('debug');
|
|
this.id = 0;
|
this._applyFunctions = [];
|
}
|
|
var nextRenderStateId = 0;
|
var renderStateCache = {};
|
|
/**
|
* Validates and then finds or creates an immutable render state, which defines the pipeline
|
* state for a {@link DrawCommand} or {@link ClearCommand}. All inputs states are optional. Omitted states
|
* use the defaults shown in the example below.
|
*
|
* @param {Object} [renderState] The states defining the render state as shown in the example below.
|
*
|
* @exception {RuntimeError} renderState.lineWidth is out of range.
|
* @exception {DeveloperError} Invalid renderState.frontFace.
|
* @exception {DeveloperError} Invalid renderState.cull.face.
|
* @exception {DeveloperError} scissorTest.rectangle.width and scissorTest.rectangle.height must be greater than or equal to zero.
|
* @exception {DeveloperError} renderState.depthRange.near can't be greater than renderState.depthRange.far.
|
* @exception {DeveloperError} renderState.depthRange.near must be greater than or equal to zero.
|
* @exception {DeveloperError} renderState.depthRange.far must be less than or equal to zero.
|
* @exception {DeveloperError} Invalid renderState.depthTest.func.
|
* @exception {DeveloperError} renderState.blending.color components must be greater than or equal to zero and less than or equal to one
|
* @exception {DeveloperError} Invalid renderState.blending.equationRgb.
|
* @exception {DeveloperError} Invalid renderState.blending.equationAlpha.
|
* @exception {DeveloperError} Invalid renderState.blending.functionSourceRgb.
|
* @exception {DeveloperError} Invalid renderState.blending.functionSourceAlpha.
|
* @exception {DeveloperError} Invalid renderState.blending.functionDestinationRgb.
|
* @exception {DeveloperError} Invalid renderState.blending.functionDestinationAlpha.
|
* @exception {DeveloperError} Invalid renderState.stencilTest.frontFunction.
|
* @exception {DeveloperError} Invalid renderState.stencilTest.backFunction.
|
* @exception {DeveloperError} Invalid renderState.stencilTest.frontOperation.fail.
|
* @exception {DeveloperError} Invalid renderState.stencilTest.frontOperation.zFail.
|
* @exception {DeveloperError} Invalid renderState.stencilTest.frontOperation.zPass.
|
* @exception {DeveloperError} Invalid renderState.stencilTest.backOperation.fail.
|
* @exception {DeveloperError} Invalid renderState.stencilTest.backOperation.zFail.
|
* @exception {DeveloperError} Invalid renderState.stencilTest.backOperation.zPass.
|
* @exception {DeveloperError} renderState.viewport.width must be greater than or equal to zero.
|
* @exception {DeveloperError} renderState.viewport.width must be less than or equal to the maximum viewport width.
|
* @exception {DeveloperError} renderState.viewport.height must be greater than or equal to zero.
|
* @exception {DeveloperError} renderState.viewport.height must be less than or equal to the maximum viewport height.
|
*
|
*
|
* @example
|
* var defaults = {
|
* frontFace : WindingOrder.COUNTER_CLOCKWISE,
|
* cull : {
|
* enabled : false,
|
* face : CullFace.BACK
|
* },
|
* lineWidth : 1,
|
* polygonOffset : {
|
* enabled : false,
|
* factor : 0,
|
* units : 0
|
* },
|
* scissorTest : {
|
* enabled : false,
|
* rectangle : {
|
* x : 0,
|
* y : 0,
|
* width : 0,
|
* height : 0
|
* }
|
* },
|
* depthRange : {
|
* near : 0,
|
* far : 1
|
* },
|
* depthTest : {
|
* enabled : false,
|
* func : DepthFunction.LESS
|
* },
|
* colorMask : {
|
* red : true,
|
* green : true,
|
* blue : true,
|
* alpha : true
|
* },
|
* depthMask : true,
|
* stencilMask : ~0,
|
* blending : {
|
* enabled : false,
|
* color : {
|
* red : 0.0,
|
* green : 0.0,
|
* blue : 0.0,
|
* alpha : 0.0
|
* },
|
* equationRgb : BlendEquation.ADD,
|
* equationAlpha : BlendEquation.ADD,
|
* functionSourceRgb : BlendFunction.ONE,
|
* functionSourceAlpha : BlendFunction.ONE,
|
* functionDestinationRgb : BlendFunction.ZERO,
|
* functionDestinationAlpha : BlendFunction.ZERO
|
* },
|
* stencilTest : {
|
* enabled : false,
|
* frontFunction : StencilFunction.ALWAYS,
|
* backFunction : StencilFunction.ALWAYS,
|
* reference : 0,
|
* mask : ~0,
|
* frontOperation : {
|
* fail : StencilOperation.KEEP,
|
* zFail : StencilOperation.KEEP,
|
* zPass : StencilOperation.KEEP
|
* },
|
* backOperation : {
|
* fail : StencilOperation.KEEP,
|
* zFail : StencilOperation.KEEP,
|
* zPass : StencilOperation.KEEP
|
* }
|
* },
|
* sampleCoverage : {
|
* enabled : false,
|
* value : 1.0,
|
* invert : false
|
* }
|
* };
|
*
|
* var rs = RenderState.fromCache(defaults);
|
*
|
* @see DrawCommand
|
* @see ClearCommand
|
*
|
* @private
|
*/
|
RenderState.fromCache = function(renderState) {
|
var partialKey = JSON.stringify(renderState);
|
var cachedState = renderStateCache[partialKey];
|
if (defined(cachedState)) {
|
++cachedState.referenceCount;
|
return cachedState.state;
|
}
|
|
// Cache miss. Fully define render state and try again.
|
var states = new RenderState(renderState);
|
var fullKey = JSON.stringify(states);
|
cachedState = renderStateCache[fullKey];
|
if (!defined(cachedState)) {
|
states.id = nextRenderStateId++;
|
//>>includeStart('debug', pragmas.debug);
|
states = freezeRenderState(states);
|
//>>includeEnd('debug');
|
cachedState = {
|
referenceCount : 0,
|
state : states
|
};
|
|
// Cache full render state. Multiple partially defined render states may map to this.
|
renderStateCache[fullKey] = cachedState;
|
}
|
|
++cachedState.referenceCount;
|
|
// Cache partial render state so we can skip validation on a cache hit for a partially defined render state
|
renderStateCache[partialKey] = {
|
referenceCount : 1,
|
state : cachedState.state
|
};
|
|
return cachedState.state;
|
};
|
|
/**
|
* @private
|
*/
|
RenderState.removeFromCache = function(renderState) {
|
var states = new RenderState(renderState);
|
var fullKey = JSON.stringify(states);
|
var fullCachedState = renderStateCache[fullKey];
|
|
// decrement partial key reference count
|
var partialKey = JSON.stringify(renderState);
|
var cachedState = renderStateCache[partialKey];
|
if (defined(cachedState)) {
|
--cachedState.referenceCount;
|
|
if (cachedState.referenceCount === 0) {
|
// remove partial key
|
delete renderStateCache[partialKey];
|
|
// decrement full key reference count
|
if (defined(fullCachedState)) {
|
--fullCachedState.referenceCount;
|
}
|
}
|
}
|
|
// remove full key if reference count is zero
|
if (defined(fullCachedState) && (fullCachedState.referenceCount === 0)) {
|
delete renderStateCache[fullKey];
|
}
|
};
|
|
/**
|
* This function is for testing purposes only.
|
* @private
|
*/
|
RenderState.getCache = function() {
|
return renderStateCache;
|
};
|
|
/**
|
* This function is for testing purposes only.
|
* @private
|
*/
|
RenderState.clearCache = function() {
|
renderStateCache = {};
|
};
|
|
function enableOrDisable(gl, glEnum, enable) {
|
if (enable) {
|
gl.enable(glEnum);
|
} else {
|
gl.disable(glEnum);
|
}
|
}
|
|
function applyFrontFace(gl, renderState) {
|
gl.frontFace(renderState.frontFace);
|
}
|
|
function applyCull(gl, renderState) {
|
var cull = renderState.cull;
|
var enabled = cull.enabled;
|
|
enableOrDisable(gl, gl.CULL_FACE, enabled);
|
|
if (enabled) {
|
gl.cullFace(cull.face);
|
}
|
}
|
|
function applyLineWidth(gl, renderState) {
|
gl.lineWidth(renderState.lineWidth);
|
}
|
|
function applyPolygonOffset(gl, renderState) {
|
var polygonOffset = renderState.polygonOffset;
|
var enabled = polygonOffset.enabled;
|
|
enableOrDisable(gl, gl.POLYGON_OFFSET_FILL, enabled);
|
|
if (enabled) {
|
gl.polygonOffset(polygonOffset.factor, polygonOffset.units);
|
}
|
}
|
|
function applyScissorTest(gl, renderState, passState) {
|
var scissorTest = renderState.scissorTest;
|
var enabled = (defined(passState.scissorTest)) ? passState.scissorTest.enabled : scissorTest.enabled;
|
|
enableOrDisable(gl, gl.SCISSOR_TEST, enabled);
|
|
if (enabled) {
|
var rectangle = (defined(passState.scissorTest)) ? passState.scissorTest.rectangle : scissorTest.rectangle;
|
gl.scissor(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
|
}
|
}
|
|
function applyDepthRange(gl, renderState) {
|
var depthRange = renderState.depthRange;
|
gl.depthRange(depthRange.near, depthRange.far);
|
}
|
|
function applyDepthTest(gl, renderState) {
|
var depthTest = renderState.depthTest;
|
var enabled = depthTest.enabled;
|
|
enableOrDisable(gl, gl.DEPTH_TEST, enabled);
|
|
if (enabled) {
|
gl.depthFunc(depthTest.func);
|
}
|
}
|
|
function applyColorMask(gl, renderState) {
|
var colorMask = renderState.colorMask;
|
gl.colorMask(colorMask.red, colorMask.green, colorMask.blue, colorMask.alpha);
|
}
|
|
function applyDepthMask(gl, renderState) {
|
gl.depthMask(renderState.depthMask);
|
}
|
|
function applyStencilMask(gl, renderState) {
|
gl.stencilMask(renderState.stencilMask);
|
}
|
|
function applyBlendingColor(gl, color) {
|
gl.blendColor(color.red, color.green, color.blue, color.alpha);
|
}
|
|
function applyBlending(gl, renderState, passState) {
|
var blending = renderState.blending;
|
var enabled = (defined(passState.blendingEnabled)) ? passState.blendingEnabled : blending.enabled;
|
|
enableOrDisable(gl, gl.BLEND, enabled);
|
|
if (enabled) {
|
applyBlendingColor(gl, blending.color);
|
gl.blendEquationSeparate(blending.equationRgb, blending.equationAlpha);
|
gl.blendFuncSeparate(blending.functionSourceRgb, blending.functionDestinationRgb, blending.functionSourceAlpha, blending.functionDestinationAlpha);
|
}
|
}
|
|
function applyStencilTest(gl, renderState) {
|
var stencilTest = renderState.stencilTest;
|
var enabled = stencilTest.enabled;
|
|
enableOrDisable(gl, gl.STENCIL_TEST, enabled);
|
|
if (enabled) {
|
var frontFunction = stencilTest.frontFunction;
|
var backFunction = stencilTest.backFunction;
|
var reference = stencilTest.reference;
|
var mask = stencilTest.mask;
|
|
// Section 6.8 of the WebGL spec requires the reference and masks to be the same for
|
// front- and back-face tests. This call prevents invalid operation errors when calling
|
// stencilFuncSeparate on Firefox. Perhaps they should delay validation to avoid requiring this.
|
gl.stencilFunc(frontFunction, reference, mask);
|
gl.stencilFuncSeparate(gl.BACK, backFunction, reference, mask);
|
gl.stencilFuncSeparate(gl.FRONT, frontFunction, reference, mask);
|
|
var frontOperation = stencilTest.frontOperation;
|
var frontOperationFail = frontOperation.fail;
|
var frontOperationZFail = frontOperation.zFail;
|
var frontOperationZPass = frontOperation.zPass;
|
|
gl.stencilOpSeparate(gl.FRONT, frontOperationFail, frontOperationZFail, frontOperationZPass);
|
|
var backOperation = stencilTest.backOperation;
|
var backOperationFail = backOperation.fail;
|
var backOperationZFail = backOperation.zFail;
|
var backOperationZPass = backOperation.zPass;
|
|
gl.stencilOpSeparate(gl.BACK, backOperationFail, backOperationZFail, backOperationZPass);
|
}
|
}
|
|
function applySampleCoverage(gl, renderState) {
|
var sampleCoverage = renderState.sampleCoverage;
|
var enabled = sampleCoverage.enabled;
|
|
enableOrDisable(gl, gl.SAMPLE_COVERAGE, enabled);
|
|
if (enabled) {
|
gl.sampleCoverage(sampleCoverage.value, sampleCoverage.invert);
|
}
|
}
|
|
var scratchViewport = new BoundingRectangle();
|
|
function applyViewport(gl, renderState, passState) {
|
var viewport = defaultValue(renderState.viewport, passState.viewport);
|
if (!defined(viewport)) {
|
viewport = scratchViewport;
|
viewport.width = passState.context.drawingBufferWidth;
|
viewport.height = passState.context.drawingBufferHeight;
|
}
|
|
passState.context.uniformState.viewport = viewport;
|
gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
|
}
|
|
RenderState.apply = function(gl, renderState, passState) {
|
applyFrontFace(gl, renderState);
|
applyCull(gl, renderState);
|
applyLineWidth(gl, renderState);
|
applyPolygonOffset(gl, renderState);
|
applyDepthRange(gl, renderState);
|
applyDepthTest(gl, renderState);
|
applyColorMask(gl, renderState);
|
applyDepthMask(gl, renderState);
|
applyStencilMask(gl, renderState);
|
applyStencilTest(gl, renderState);
|
applySampleCoverage(gl, renderState);
|
applyScissorTest(gl, renderState, passState);
|
applyBlending(gl, renderState, passState);
|
applyViewport(gl, renderState, passState);
|
};
|
|
function createFuncs(previousState, nextState) {
|
var funcs = [];
|
|
if (previousState.frontFace !== nextState.frontFace) {
|
funcs.push(applyFrontFace);
|
}
|
|
if ((previousState.cull.enabled !== nextState.cull.enabled) || (previousState.cull.face !== nextState.cull.face)) {
|
funcs.push(applyCull);
|
}
|
|
if (previousState.lineWidth !== nextState.lineWidth) {
|
funcs.push(applyLineWidth);
|
}
|
|
if ((previousState.polygonOffset.enabled !== nextState.polygonOffset.enabled) ||
|
(previousState.polygonOffset.factor !== nextState.polygonOffset.factor) ||
|
(previousState.polygonOffset.units !== nextState.polygonOffset.units)) {
|
funcs.push(applyPolygonOffset);
|
}
|
|
if ((previousState.depthRange.near !== nextState.depthRange.near) || (previousState.depthRange.far !== nextState.depthRange.far)) {
|
funcs.push(applyDepthRange);
|
}
|
|
if ((previousState.depthTest.enabled !== nextState.depthTest.enabled) || (previousState.depthTest.func !== nextState.depthTest.func)) {
|
funcs.push(applyDepthTest);
|
}
|
|
if ((previousState.colorMask.red !== nextState.colorMask.red) ||
|
(previousState.colorMask.green !== nextState.colorMask.green) ||
|
(previousState.colorMask.blue !== nextState.colorMask.blue) ||
|
(previousState.colorMask.alpha !== nextState.colorMask.alpha)) {
|
funcs.push(applyColorMask);
|
}
|
|
if (previousState.depthMask !== nextState.depthMask) {
|
funcs.push(applyDepthMask);
|
}
|
|
if (previousState.stencilMask !== nextState.stencilMask) {
|
funcs.push(applyStencilMask);
|
}
|
|
if ((previousState.stencilTest.enabled !== nextState.stencilTest.enabled) ||
|
(previousState.stencilTest.frontFunction !== nextState.stencilTest.frontFunction) ||
|
(previousState.stencilTest.backFunction !== nextState.stencilTest.backFunction) ||
|
(previousState.stencilTest.reference !== nextState.stencilTest.reference) ||
|
(previousState.stencilTest.mask !== nextState.stencilTest.mask) ||
|
(previousState.stencilTest.frontOperation.fail !== nextState.stencilTest.frontOperation.fail) ||
|
(previousState.stencilTest.frontOperation.zFail !== nextState.stencilTest.frontOperation.zFail) ||
|
(previousState.stencilTest.backOperation.fail !== nextState.stencilTest.backOperation.fail) ||
|
(previousState.stencilTest.backOperation.zFail !== nextState.stencilTest.backOperation.zFail) ||
|
(previousState.stencilTest.backOperation.zPass !== nextState.stencilTest.backOperation.zPass)) {
|
funcs.push(applyStencilTest);
|
}
|
|
if ((previousState.sampleCoverage.enabled !== nextState.sampleCoverage.enabled) ||
|
(previousState.sampleCoverage.value !== nextState.sampleCoverage.value) ||
|
(previousState.sampleCoverage.invert !== nextState.sampleCoverage.invert)) {
|
funcs.push(applySampleCoverage);
|
}
|
|
return funcs;
|
}
|
|
RenderState.partialApply = function(gl, previousRenderState, renderState, previousPassState, passState, clear) {
|
if (previousRenderState !== renderState) {
|
// When a new render state is applied, instead of making WebGL calls for all the states or first
|
// comparing the states one-by-one with the previous state (basically a linear search), we take
|
// advantage of RenderState's immutability, and store a dynamically populated sparse data structure
|
// containing functions that make the minimum number of WebGL calls when transitioning from one state
|
// to the other. In practice, this works well since state-to-state transitions generally only require a
|
// few WebGL calls, especially if commands are stored by state.
|
var funcs = renderState._applyFunctions[previousRenderState.id];
|
if (!defined(funcs)) {
|
funcs = createFuncs(previousRenderState, renderState);
|
renderState._applyFunctions[previousRenderState.id] = funcs;
|
}
|
|
var len = funcs.length;
|
for (var i = 0; i < len; ++i) {
|
funcs[i](gl, renderState);
|
}
|
}
|
|
var previousScissorTest = (defined(previousPassState.scissorTest)) ? previousPassState.scissorTest : previousRenderState.scissorTest;
|
var scissorTest = (defined(passState.scissorTest)) ? passState.scissorTest : renderState.scissorTest;
|
|
// Our scissor rectangle can get out of sync with the GL scissor rectangle on clears.
|
// Seems to be a problem only on ANGLE. See https://github.com/CesiumGS/cesium/issues/2994
|
if ((previousScissorTest !== scissorTest) || clear) {
|
applyScissorTest(gl, renderState, passState);
|
}
|
|
var previousBlendingEnabled = (defined(previousPassState.blendingEnabled)) ? previousPassState.blendingEnabled : previousRenderState.blending.enabled;
|
var blendingEnabled = (defined(passState.blendingEnabled)) ? passState.blendingEnabled : renderState.blending.enabled;
|
if ((previousBlendingEnabled !== blendingEnabled) ||
|
(blendingEnabled && (previousRenderState.blending !== renderState.blending))) {
|
applyBlending(gl, renderState, passState);
|
}
|
|
if (previousRenderState !== renderState || previousPassState !== passState || previousPassState.context !== passState.context) {
|
applyViewport(gl, renderState, passState);
|
}
|
};
|
|
RenderState.getState = function(renderState) {
|
//>>includeStart('debug', pragmas.debug);
|
if (!defined(renderState)) {
|
throw new DeveloperError('renderState is required.');
|
}
|
//>>includeEnd('debug');
|
|
return {
|
frontFace : renderState.frontFace,
|
cull : {
|
enabled : renderState.cull.enabled,
|
face : renderState.cull.face
|
},
|
lineWidth : renderState.lineWidth,
|
polygonOffset : {
|
enabled : renderState.polygonOffset.enabled,
|
factor : renderState.polygonOffset.factor,
|
units : renderState.polygonOffset.units
|
},
|
scissorTest : {
|
enabled : renderState.scissorTest.enabled,
|
rectangle : BoundingRectangle.clone(renderState.scissorTest.rectangle)
|
},
|
depthRange : {
|
near : renderState.depthRange.near,
|
far : renderState.depthRange.far
|
},
|
depthTest : {
|
enabled : renderState.depthTest.enabled,
|
func : renderState.depthTest.func
|
},
|
colorMask : {
|
red : renderState.colorMask.red,
|
green : renderState.colorMask.green,
|
blue : renderState.colorMask.blue,
|
alpha : renderState.colorMask.alpha
|
},
|
depthMask : renderState.depthMask,
|
stencilMask : renderState.stencilMask,
|
blending : {
|
enabled : renderState.blending.enabled,
|
color : Color.clone(renderState.blending.color),
|
equationRgb : renderState.blending.equationRgb,
|
equationAlpha : renderState.blending.equationAlpha,
|
functionSourceRgb : renderState.blending.functionSourceRgb,
|
functionSourceAlpha : renderState.blending.functionSourceAlpha,
|
functionDestinationRgb : renderState.blending.functionDestinationRgb,
|
functionDestinationAlpha : renderState.blending.functionDestinationAlpha
|
},
|
stencilTest : {
|
enabled : renderState.stencilTest.enabled,
|
frontFunction : renderState.stencilTest.frontFunction,
|
backFunction : renderState.stencilTest.backFunction,
|
reference : renderState.stencilTest.reference,
|
mask : renderState.stencilTest.mask,
|
frontOperation : {
|
fail : renderState.stencilTest.frontOperation.fail,
|
zFail : renderState.stencilTest.frontOperation.zFail,
|
zPass : renderState.stencilTest.frontOperation.zPass
|
},
|
backOperation : {
|
fail : renderState.stencilTest.backOperation.fail,
|
zFail : renderState.stencilTest.backOperation.zFail,
|
zPass : renderState.stencilTest.backOperation.zPass
|
}
|
},
|
sampleCoverage : {
|
enabled : renderState.sampleCoverage.enabled,
|
value : renderState.sampleCoverage.value,
|
invert : renderState.sampleCoverage.invert
|
},
|
viewport : defined(renderState.viewport) ? BoundingRectangle.clone(renderState.viewport) : undefined
|
};
|
};
|
export default RenderState;
|
