Skip to content

A
angle
Commit 758b12fa by Jiacheng Lu Committed by Commit Bot
Options

Filter out redundant depth&stencil state updates

1. Compare updating values with active ones at frontend when depth&stencil related gl call happens and do not set any unnecessary dirty bits. 2. Remove d3d and gl backends' checking of depth&stencil states when detect any dirty bits, as it is now being done at frontend. 3. Modification to graphics pipeline description update, make sure it syncs with gl::State initial value. 4. Change gl_vk::CullMode return type to VkCullModeFlagBits, as it only represents single value. Bug: angleproject:3700 Change-Id: Id3aa5186455ee3a10a9c147edad13944e3e41098 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1706903 Commit-Queue: Jiacheng Lu <lujc@google.com> Reviewed-by: 's avatarTobin Ehlis <tobine@google.com>
parent c405776e
Showing with 198 additions and 260 deletions
src/libANGLE/Context.cpp
...@@ -4822,14 +4822,15 @@ void Context::scissor(GLint x, GLint y, GLsizei width, GLsizei height) ...@@ -4822,14 +4822,15 @@ void Context::scissor(GLint x, GLint y, GLsizei width, GLsizei height)
void Context::stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) void Context::stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{ {
GLint clampedRef = gl::clamp(ref, 0, std::numeric_limits<uint8_t>::max());
if (face == GL_FRONT || face == GL_FRONT_AND_BACK) if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
{ {
mState.setStencilParams(func, ref, mask); mState.setStencilParams(func, clampedRef, mask);
} }
if (face == GL_BACK || face == GL_FRONT_AND_BACK) if (face == GL_BACK || face == GL_FRONT_AND_BACK)
{ {
mState.setStencilBackParams(func, ref, mask); mState.setStencilBackParams(func, clampedRef, mask);
} }
mStateCache.onStencilStateChange(this); mStateCache.onStencilStateChange(this);
......
src/libANGLE/State.cpp
...@@ -623,8 +623,11 @@ void State::setColorMask(bool red, bool green, bool blue, bool alpha) ...@@ -623,8 +623,11 @@ void State::setColorMask(bool red, bool green, bool blue, bool alpha)
void State::setDepthMask(bool mask) void State::setDepthMask(bool mask)
{ {
mDepthStencil.depthMask = mask; if (mDepthStencil.depthMask != mask)
mDirtyBits.set(DIRTY_BIT_DEPTH_MASK); {
mDepthStencil.depthMask = mask;
mDirtyBits.set(DIRTY_BIT_DEPTH_MASK);
}
} }
void State::setRasterizerDiscard(bool enabled) void State::setRasterizerDiscard(bool enabled)
...@@ -653,14 +656,20 @@ void State::setFrontFace(GLenum front) ...@@ -653,14 +656,20 @@ void State::setFrontFace(GLenum front)
void State::setDepthTest(bool enabled) void State::setDepthTest(bool enabled)
{ {
mDepthStencil.depthTest = enabled; if (mDepthStencil.depthTest != enabled)
mDirtyBits.set(DIRTY_BIT_DEPTH_TEST_ENABLED); {
mDepthStencil.depthTest = enabled;
mDirtyBits.set(DIRTY_BIT_DEPTH_TEST_ENABLED);
}
} }
void State::setDepthFunc(GLenum depthFunc) void State::setDepthFunc(GLenum depthFunc)
{ {
mDepthStencil.depthFunc = depthFunc; if (mDepthStencil.depthFunc != depthFunc)
mDirtyBits.set(DIRTY_BIT_DEPTH_FUNC); {
mDepthStencil.depthFunc = depthFunc;
mDirtyBits.set(DIRTY_BIT_DEPTH_FUNC);
}
} }
void State::setDepthRange(float zNear, float zFar) void State::setDepthRange(float zNear, float zFar)
...@@ -706,58 +715,85 @@ void State::setBlendEquation(GLenum rgbEquation, GLenum alphaEquation) ...@@ -706,58 +715,85 @@ void State::setBlendEquation(GLenum rgbEquation, GLenum alphaEquation)
void State::setStencilTest(bool enabled) void State::setStencilTest(bool enabled)
{ {
mDepthStencil.stencilTest = enabled; if (mDepthStencil.stencilTest != enabled)
mDirtyBits.set(DIRTY_BIT_STENCIL_TEST_ENABLED); {
mDepthStencil.stencilTest = enabled;
mDirtyBits.set(DIRTY_BIT_STENCIL_TEST_ENABLED);
}
} }
void State::setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask) void State::setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask)
{ {
mDepthStencil.stencilFunc = stencilFunc; if (mDepthStencil.stencilFunc != stencilFunc || mStencilRef != stencilRef ||
mStencilRef = gl::clamp(stencilRef, 0, std::numeric_limits<uint8_t>::max()); mDepthStencil.stencilMask != stencilMask)
mDepthStencil.stencilMask = stencilMask; {
mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_FRONT); mDepthStencil.stencilFunc = stencilFunc;
mStencilRef = stencilRef;
mDepthStencil.stencilMask = stencilMask;
mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_FRONT);
}
} }
void State::setStencilBackParams(GLenum stencilBackFunc, void State::setStencilBackParams(GLenum stencilBackFunc,
GLint stencilBackRef, GLint stencilBackRef,
GLuint stencilBackMask) GLuint stencilBackMask)
{ {
mDepthStencil.stencilBackFunc = stencilBackFunc; if (mDepthStencil.stencilBackFunc != stencilBackFunc || mStencilBackRef != stencilBackRef ||
mStencilBackRef = gl::clamp(stencilBackRef, 0, std::numeric_limits<uint8_t>::max()); mDepthStencil.stencilBackMask != stencilBackMask)
mDepthStencil.stencilBackMask = stencilBackMask; {
mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_BACK); mDepthStencil.stencilBackFunc = stencilBackFunc;
mStencilBackRef = stencilBackRef;
mDepthStencil.stencilBackMask = stencilBackMask;
mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_BACK);
}
} }
void State::setStencilWritemask(GLuint stencilWritemask) void State::setStencilWritemask(GLuint stencilWritemask)
{ {
mDepthStencil.stencilWritemask = stencilWritemask; if (mDepthStencil.stencilWritemask != stencilWritemask)
mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_FRONT); {
mDepthStencil.stencilWritemask = stencilWritemask;
mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_FRONT);
}
} }
void State::setStencilBackWritemask(GLuint stencilBackWritemask) void State::setStencilBackWritemask(GLuint stencilBackWritemask)
{ {
mDepthStencil.stencilBackWritemask = stencilBackWritemask; if (mDepthStencil.stencilBackWritemask != stencilBackWritemask)
mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_BACK); {
mDepthStencil.stencilBackWritemask = stencilBackWritemask;
mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_BACK);
}
} }
void State::setStencilOperations(GLenum stencilFail, void State::setStencilOperations(GLenum stencilFail,
GLenum stencilPassDepthFail, GLenum stencilPassDepthFail,
GLenum stencilPassDepthPass) GLenum stencilPassDepthPass)
{ {
mDepthStencil.stencilFail = stencilFail; if (mDepthStencil.stencilFail != stencilFail ||
mDepthStencil.stencilPassDepthFail = stencilPassDepthFail; mDepthStencil.stencilPassDepthFail != stencilPassDepthFail ||
mDepthStencil.stencilPassDepthPass = stencilPassDepthPass; mDepthStencil.stencilPassDepthPass != stencilPassDepthPass)
mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_FRONT); {
mDepthStencil.stencilFail = stencilFail;
mDepthStencil.stencilPassDepthFail = stencilPassDepthFail;
mDepthStencil.stencilPassDepthPass = stencilPassDepthPass;
mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_FRONT);
}
} }
void State::setStencilBackOperations(GLenum stencilBackFail, void State::setStencilBackOperations(GLenum stencilBackFail,
GLenum stencilBackPassDepthFail, GLenum stencilBackPassDepthFail,
GLenum stencilBackPassDepthPass) GLenum stencilBackPassDepthPass)
{ {
mDepthStencil.stencilBackFail = stencilBackFail; if (mDepthStencil.stencilBackFail != stencilBackFail ||
mDepthStencil.stencilBackPassDepthFail = stencilBackPassDepthFail; mDepthStencil.stencilBackPassDepthFail != stencilBackPassDepthFail ||
mDepthStencil.stencilBackPassDepthPass = stencilBackPassDepthPass; mDepthStencil.stencilBackPassDepthPass != stencilBackPassDepthPass)
mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_BACK); {
mDepthStencil.stencilBackFail = stencilBackFail;
mDepthStencil.stencilBackPassDepthFail = stencilBackPassDepthFail;
mDepthStencil.stencilBackPassDepthPass = stencilBackPassDepthPass;
mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_BACK);
}
} }
void State::setPolygonOffsetFill(bool enabled) void State::setPolygonOffsetFill(bool enabled)
......
src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp
...@@ -1015,91 +1015,39 @@ void StateManager11::syncState(const gl::Context *context, const gl::State::Dirt ...@@ -1015,91 +1015,39 @@ void StateManager11::syncState(const gl::Context *context, const gl::State::Dirt
mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE); mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE);
} }
break; break;
// Depth and stencil redundant state changes are guarded in the
// frontend so for related cases here just set the dirty bit.
case gl::State::DIRTY_BIT_DEPTH_MASK: case gl::State::DIRTY_BIT_DEPTH_MASK:
if (state.getDepthStencilState().depthMask != mCurDepthStencilState.depthMask) mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
{
mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
}
break; break;
case gl::State::DIRTY_BIT_DEPTH_TEST_ENABLED: case gl::State::DIRTY_BIT_DEPTH_TEST_ENABLED:
if (state.getDepthStencilState().depthTest != mCurDepthStencilState.depthTest) mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
{
mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
}
break; break;
case gl::State::DIRTY_BIT_DEPTH_FUNC: case gl::State::DIRTY_BIT_DEPTH_FUNC:
if (state.getDepthStencilState().depthFunc != mCurDepthStencilState.depthFunc) mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
{
mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
}
break; break;
case gl::State::DIRTY_BIT_STENCIL_TEST_ENABLED: case gl::State::DIRTY_BIT_STENCIL_TEST_ENABLED:
if (state.getDepthStencilState().stencilTest != mCurDepthStencilState.stencilTest) mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
{
mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
}
break; break;
case gl::State::DIRTY_BIT_STENCIL_FUNCS_FRONT: case gl::State::DIRTY_BIT_STENCIL_FUNCS_FRONT:
{ mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
const gl::DepthStencilState &depthStencil = state.getDepthStencilState();
if (depthStencil.stencilFunc != mCurDepthStencilState.stencilFunc ||
depthStencil.stencilMask != mCurDepthStencilState.stencilMask ||
state.getStencilRef() != mCurStencilRef)
{
mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
}
break; break;
}
case gl::State::DIRTY_BIT_STENCIL_FUNCS_BACK: case gl::State::DIRTY_BIT_STENCIL_FUNCS_BACK:
{ mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
const gl::DepthStencilState &depthStencil = state.getDepthStencilState();
if (depthStencil.stencilBackFunc != mCurDepthStencilState.stencilBackFunc ||
depthStencil.stencilBackMask != mCurDepthStencilState.stencilBackMask ||
state.getStencilBackRef() != mCurStencilBackRef)
{
mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
}
break; break;
}
case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_FRONT: case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_FRONT:
if (state.getDepthStencilState().stencilWritemask != mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
mCurDepthStencilState.stencilWritemask)
{
mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
}
break; break;
case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_BACK: case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_BACK:
if (state.getDepthStencilState().stencilBackWritemask != mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
mCurDepthStencilState.stencilBackWritemask)
{
mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
}
break; break;
case gl::State::DIRTY_BIT_STENCIL_OPS_FRONT: case gl::State::DIRTY_BIT_STENCIL_OPS_FRONT:
{ mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
const gl::DepthStencilState &depthStencil = state.getDepthStencilState();
if (depthStencil.stencilFail != mCurDepthStencilState.stencilFail ||
depthStencil.stencilPassDepthFail !=
mCurDepthStencilState.stencilPassDepthFail ||
depthStencil.stencilPassDepthPass != mCurDepthStencilState.stencilPassDepthPass)
{
mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
}
break; break;
}
case gl::State::DIRTY_BIT_STENCIL_OPS_BACK: case gl::State::DIRTY_BIT_STENCIL_OPS_BACK:
{ mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
const gl::DepthStencilState &depthStencil = state.getDepthStencilState();
if (depthStencil.stencilBackFail != mCurDepthStencilState.stencilBackFail ||
depthStencil.stencilBackPassDepthFail !=
mCurDepthStencilState.stencilBackPassDepthFail ||
depthStencil.stencilBackPassDepthPass !=
mCurDepthStencilState.stencilBackPassDepthPass)
{
mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
}
break; break;
}
case gl::State::DIRTY_BIT_CULL_FACE_ENABLED: case gl::State::DIRTY_BIT_CULL_FACE_ENABLED:
if (state.getRasterizerState().cullFace != mCurRasterState.cullFace) if (state.getRasterizerState().cullFace != mCurRasterState.cullFace)
{ {
......
src/libANGLE/renderer/d3d/d3d9/StateManager9.cpp
...@@ -250,6 +250,8 @@ void StateManager9::syncState(const gl::State &state, const gl::State::DirtyBits ...@@ -250,6 +250,8 @@ void StateManager9::syncState(const gl::State &state, const gl::State::DirtyBits
} }
break; break;
} }
// Depth and stencil redundant state changes are guarded in the
// frontend so for related cases here just set the dirty bit.
case gl::State::DIRTY_BIT_DEPTH_MASK: case gl::State::DIRTY_BIT_DEPTH_MASK:
if (state.getDepthStencilState().depthMask != mCurDepthStencilState.depthMask) if (state.getDepthStencilState().depthMask != mCurDepthStencilState.depthMask)
{ {
...@@ -257,92 +259,39 @@ void StateManager9::syncState(const gl::State &state, const gl::State::DirtyBits ...@@ -257,92 +259,39 @@ void StateManager9::syncState(const gl::State &state, const gl::State::DirtyBits
} }
break; break;
case gl::State::DIRTY_BIT_DEPTH_TEST_ENABLED: case gl::State::DIRTY_BIT_DEPTH_TEST_ENABLED:
if (state.getDepthStencilState().depthTest != mCurDepthStencilState.depthTest) mDirtyBits.set(DIRTY_BIT_STENCIL_DEPTH_FUNC);
{
mDirtyBits.set(DIRTY_BIT_STENCIL_DEPTH_FUNC);
}
break; break;
case gl::State::DIRTY_BIT_DEPTH_FUNC: case gl::State::DIRTY_BIT_DEPTH_FUNC:
if (state.getDepthStencilState().depthFunc != mCurDepthStencilState.depthFunc) mDirtyBits.set(DIRTY_BIT_STENCIL_DEPTH_FUNC);
{
mDirtyBits.set(DIRTY_BIT_STENCIL_DEPTH_FUNC);
}
break; break;
case gl::State::DIRTY_BIT_STENCIL_TEST_ENABLED: case gl::State::DIRTY_BIT_STENCIL_TEST_ENABLED:
if (state.getDepthStencilState().stencilTest != mCurDepthStencilState.stencilTest) mDirtyBits.set(DIRTY_BIT_STENCIL_TEST_ENABLED);
{ // If we enable the stencil test, all of these must be set
mDirtyBits.set(DIRTY_BIT_STENCIL_TEST_ENABLED); mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_BACK);
// If we enable the stencil test, all of these must be set mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_FRONT);
mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_BACK); mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_FRONT);
mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_FRONT); mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_BACK);
mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_FRONT); mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_FRONT);
mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_BACK); mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_BACK);
mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_FRONT);
mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_BACK);
}
break; break;
case gl::State::DIRTY_BIT_STENCIL_FUNCS_FRONT: case gl::State::DIRTY_BIT_STENCIL_FUNCS_FRONT:
{ mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_FRONT);
const gl::DepthStencilState &depthStencilState = state.getDepthStencilState();
if (depthStencilState.stencilFunc != mCurDepthStencilState.stencilFunc ||
depthStencilState.stencilMask != mCurDepthStencilState.stencilMask ||
state.getStencilRef() != mCurStencilRef)
{
mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_FRONT);
}
break; break;
}
case gl::State::DIRTY_BIT_STENCIL_FUNCS_BACK: case gl::State::DIRTY_BIT_STENCIL_FUNCS_BACK:
{ mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_BACK);
const gl::DepthStencilState &depthStencilState = state.getDepthStencilState();
if (depthStencilState.stencilBackFunc != mCurDepthStencilState.stencilBackFunc ||
depthStencilState.stencilBackMask != mCurDepthStencilState.stencilBackMask ||
state.getStencilBackRef() != mCurStencilBackRef)
{
mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_BACK);
}
break; break;
}
case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_FRONT: case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_FRONT:
if (state.getDepthStencilState().stencilWritemask != mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_FRONT);
mCurDepthStencilState.stencilWritemask)
{
mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_FRONT);
}
break; break;
case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_BACK: case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_BACK:
if (state.getDepthStencilState().stencilBackWritemask != mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_BACK);
mCurDepthStencilState.stencilBackWritemask)
{
mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_BACK);
}
break; break;
case gl::State::DIRTY_BIT_STENCIL_OPS_FRONT: case gl::State::DIRTY_BIT_STENCIL_OPS_FRONT:
{ mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_FRONT);
const gl::DepthStencilState &depthStencilState = state.getDepthStencilState();
if (depthStencilState.stencilFail != mCurDepthStencilState.stencilFail ||
depthStencilState.stencilPassDepthFail !=
mCurDepthStencilState.stencilPassDepthFail ||
depthStencilState.stencilPassDepthPass !=
mCurDepthStencilState.stencilPassDepthPass)
{
mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_FRONT);
}
break; break;
}
case gl::State::DIRTY_BIT_STENCIL_OPS_BACK: case gl::State::DIRTY_BIT_STENCIL_OPS_BACK:
{ mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_BACK);
const gl::DepthStencilState &depthStencilState = state.getDepthStencilState();
if (depthStencilState.stencilBackFail != mCurDepthStencilState.stencilBackFail ||
depthStencilState.stencilBackPassDepthFail !=
mCurDepthStencilState.stencilBackPassDepthFail ||
depthStencilState.stencilBackPassDepthPass !=
mCurDepthStencilState.stencilBackPassDepthPass)
{
mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_BACK);
}
break; break;
}
case gl::State::DIRTY_BIT_SCISSOR_TEST_ENABLED: case gl::State::DIRTY_BIT_SCISSOR_TEST_ENABLED:
if (state.isScissorTestEnabled() != mCurScissorEnabled) if (state.isScissorTestEnabled() != mCurScissorEnabled)
{ {
......
src/libANGLE/renderer/gl/StateManagerGL.cpp
...@@ -1192,144 +1192,115 @@ void StateManagerGL::setSampleMaski(GLuint maskNumber, GLbitfield mask) ...@@ -1192,144 +1192,115 @@ void StateManagerGL::setSampleMaski(GLuint maskNumber, GLbitfield mask)
} }
} }
// Depth and stencil redundant state changes are guarded in the
// frontend so for related cases here just set the dirty bit
// and update backend states.
void StateManagerGL::setDepthTestEnabled(bool enabled) void StateManagerGL::setDepthTestEnabled(bool enabled)
{ {
if (mDepthTestEnabled != enabled) mDepthTestEnabled = enabled;
if (mDepthTestEnabled)
{ {
mDepthTestEnabled = enabled; mFunctions->enable(GL_DEPTH_TEST);
if (mDepthTestEnabled) }
{ else
mFunctions->enable(GL_DEPTH_TEST); {
} mFunctions->disable(GL_DEPTH_TEST);
else
{
mFunctions->disable(GL_DEPTH_TEST);
}
mLocalDirtyBits.set(gl::State::DIRTY_BIT_DEPTH_TEST_ENABLED);
} }
mLocalDirtyBits.set(gl::State::DIRTY_BIT_DEPTH_TEST_ENABLED);
} }
void StateManagerGL::setDepthFunc(GLenum depthFunc) void StateManagerGL::setDepthFunc(GLenum depthFunc)
{ {
if (mDepthFunc != depthFunc) mDepthFunc = depthFunc;
{ mFunctions->depthFunc(mDepthFunc);
mDepthFunc = depthFunc;
mFunctions->depthFunc(mDepthFunc);
mLocalDirtyBits.set(gl::State::DIRTY_BIT_DEPTH_FUNC); mLocalDirtyBits.set(gl::State::DIRTY_BIT_DEPTH_FUNC);
}
} }
void StateManagerGL::setDepthMask(bool mask) void StateManagerGL::setDepthMask(bool mask)
{ {
if (mDepthMask != mask) mDepthMask = mask;
{ mFunctions->depthMask(mDepthMask);
mDepthMask = mask;
mFunctions->depthMask(mDepthMask);
mLocalDirtyBits.set(gl::State::DIRTY_BIT_DEPTH_MASK); mLocalDirtyBits.set(gl::State::DIRTY_BIT_DEPTH_MASK);
}
} }
void StateManagerGL::setStencilTestEnabled(bool enabled) void StateManagerGL::setStencilTestEnabled(bool enabled)
{ {
if (mStencilTestEnabled != enabled) mStencilTestEnabled = enabled;
if (mStencilTestEnabled)
{ {
mStencilTestEnabled = enabled; mFunctions->enable(GL_STENCIL_TEST);
if (mStencilTestEnabled) }
{ else
mFunctions->enable(GL_STENCIL_TEST); {
} mFunctions->disable(GL_STENCIL_TEST);
else
{
mFunctions->disable(GL_STENCIL_TEST);
}
mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_TEST_ENABLED);
} }
mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_TEST_ENABLED);
} }
void StateManagerGL::setStencilFrontWritemask(GLuint mask) void StateManagerGL::setStencilFrontWritemask(GLuint mask)
{ {
if (mStencilFrontWritemask != mask) mStencilFrontWritemask = mask;
{ mFunctions->stencilMaskSeparate(GL_FRONT, mStencilFrontWritemask);
mStencilFrontWritemask = mask;
mFunctions->stencilMaskSeparate(GL_FRONT, mStencilFrontWritemask);
mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_WRITEMASK_FRONT); mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_WRITEMASK_FRONT);
}
} }
void StateManagerGL::setStencilBackWritemask(GLuint mask) void StateManagerGL::setStencilBackWritemask(GLuint mask)
{ {
if (mStencilBackWritemask != mask) mStencilBackWritemask = mask;
{ mFunctions->stencilMaskSeparate(GL_BACK, mStencilBackWritemask);
mStencilBackWritemask = mask;
mFunctions->stencilMaskSeparate(GL_BACK, mStencilBackWritemask);
mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_WRITEMASK_BACK); mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_WRITEMASK_BACK);
}
} }
void StateManagerGL::setStencilFrontFuncs(GLenum func, GLint ref, GLuint mask) void StateManagerGL::setStencilFrontFuncs(GLenum func, GLint ref, GLuint mask)
{ {
if (mStencilFrontFunc != func || mStencilFrontRef != ref || mStencilFrontValueMask != mask) mStencilFrontFunc = func;
{ mStencilFrontRef = ref;
mStencilFrontFunc = func; mStencilFrontValueMask = mask;
mStencilFrontRef = ref; mFunctions->stencilFuncSeparate(GL_FRONT, mStencilFrontFunc, mStencilFrontRef,
mStencilFrontValueMask = mask; mStencilFrontValueMask);
mFunctions->stencilFuncSeparate(GL_FRONT, mStencilFrontFunc, mStencilFrontRef,
mStencilFrontValueMask);
mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_FUNCS_FRONT); mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_FUNCS_FRONT);
}
} }
void StateManagerGL::setStencilBackFuncs(GLenum func, GLint ref, GLuint mask) void StateManagerGL::setStencilBackFuncs(GLenum func, GLint ref, GLuint mask)
{ {
if (mStencilBackFunc != func || mStencilBackRef != ref || mStencilBackValueMask != mask) mStencilBackFunc = func;
{ mStencilBackRef = ref;
mStencilBackFunc = func; mStencilBackValueMask = mask;
mStencilBackRef = ref; mFunctions->stencilFuncSeparate(GL_BACK, mStencilBackFunc, mStencilBackRef,
mStencilBackValueMask = mask; mStencilBackValueMask);
mFunctions->stencilFuncSeparate(GL_BACK, mStencilBackFunc, mStencilBackRef,
mStencilBackValueMask);
mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_FUNCS_BACK); mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_FUNCS_BACK);
}
} }
void StateManagerGL::setStencilFrontOps(GLenum sfail, GLenum dpfail, GLenum dppass) void StateManagerGL::setStencilFrontOps(GLenum sfail, GLenum dpfail, GLenum dppass)
{ {
if (mStencilFrontStencilFailOp != sfail || mStencilFrontStencilPassDepthFailOp != dpfail || mStencilFrontStencilFailOp = sfail;
mStencilFrontStencilPassDepthPassOp != dppass) mStencilFrontStencilPassDepthFailOp = dpfail;
{ mStencilFrontStencilPassDepthPassOp = dppass;
mStencilFrontStencilFailOp = sfail; mFunctions->stencilOpSeparate(GL_FRONT, mStencilFrontStencilFailOp,
mStencilFrontStencilPassDepthFailOp = dpfail; mStencilFrontStencilPassDepthFailOp,
mStencilFrontStencilPassDepthPassOp = dppass; mStencilFrontStencilPassDepthPassOp);
mFunctions->stencilOpSeparate(GL_FRONT, mStencilFrontStencilFailOp,
mStencilFrontStencilPassDepthFailOp,
mStencilFrontStencilPassDepthPassOp);
mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_OPS_FRONT); mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_OPS_FRONT);
}
} }
void StateManagerGL::setStencilBackOps(GLenum sfail, GLenum dpfail, GLenum dppass) void StateManagerGL::setStencilBackOps(GLenum sfail, GLenum dpfail, GLenum dppass)
{ {
if (mStencilBackStencilFailOp != sfail || mStencilBackStencilPassDepthFailOp != dpfail || mStencilBackStencilFailOp = sfail;
mStencilBackStencilPassDepthPassOp != dppass) mStencilBackStencilPassDepthFailOp = dpfail;
{ mStencilBackStencilPassDepthPassOp = dppass;
mStencilBackStencilFailOp = sfail; mFunctions->stencilOpSeparate(GL_BACK, mStencilBackStencilFailOp,
mStencilBackStencilPassDepthFailOp = dpfail; mStencilBackStencilPassDepthFailOp,
mStencilBackStencilPassDepthPassOp = dppass; mStencilBackStencilPassDepthPassOp);
mFunctions->stencilOpSeparate(GL_BACK, mStencilBackStencilFailOp,
mStencilBackStencilPassDepthFailOp,
mStencilBackStencilPassDepthPassOp);
mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_OPS_BACK); mLocalDirtyBits.set(gl::State::DIRTY_BIT_STENCIL_OPS_BACK);
}
} }
void StateManagerGL::setCullFaceEnabled(bool enabled) void StateManagerGL::setCullFaceEnabled(bool enabled)
......
src/libANGLE/renderer/vulkan/UtilsVk.cpp
...@@ -824,6 +824,7 @@ angle::Result UtilsVk::clearFramebuffer(ContextVk *contextVk, ...@@ -824,6 +824,7 @@ angle::Result UtilsVk::clearFramebuffer(ContextVk *contextVk,
vk::GraphicsPipelineDesc pipelineDesc; vk::GraphicsPipelineDesc pipelineDesc;
pipelineDesc.initDefaults(); pipelineDesc.initDefaults();
pipelineDesc.setCullMode(VK_CULL_MODE_NONE);
pipelineDesc.setColorWriteMask(0, gl::DrawBufferMask()); pipelineDesc.setColorWriteMask(0, gl::DrawBufferMask());
pipelineDesc.setSingleColorWriteMask(params.colorAttachmentIndexGL, params.colorMaskFlags); pipelineDesc.setSingleColorWriteMask(params.colorAttachmentIndexGL, params.colorMaskFlags);
pipelineDesc.setRasterizationSamples(framebuffer->getSamples()); pipelineDesc.setRasterizationSamples(framebuffer->getSamples());
...@@ -1000,6 +1001,7 @@ angle::Result UtilsVk::blitResolveImpl(ContextVk *contextVk, ...@@ -1000,6 +1001,7 @@ angle::Result UtilsVk::blitResolveImpl(ContextVk *contextVk,
{ {
pipelineDesc.setColorWriteMask(0, gl::DrawBufferMask()); pipelineDesc.setColorWriteMask(0, gl::DrawBufferMask());
} }
pipelineDesc.setCullMode(VK_CULL_MODE_NONE);
pipelineDesc.setRenderPassDesc(framebuffer->getRenderPassDesc()); pipelineDesc.setRenderPassDesc(framebuffer->getRenderPassDesc());
pipelineDesc.setDepthTestEnabled(blitDepth); pipelineDesc.setDepthTestEnabled(blitDepth);
pipelineDesc.setDepthWriteEnabled(blitDepth); pipelineDesc.setDepthWriteEnabled(blitDepth);
...@@ -1345,6 +1347,7 @@ angle::Result UtilsVk::copyImage(ContextVk *contextVk, ...@@ -1345,6 +1347,7 @@ angle::Result UtilsVk::copyImage(ContextVk *contextVk,
vk::GraphicsPipelineDesc pipelineDesc; vk::GraphicsPipelineDesc pipelineDesc;
pipelineDesc.initDefaults(); pipelineDesc.initDefaults();
pipelineDesc.setCullMode(VK_CULL_MODE_NONE);
pipelineDesc.setRenderPassDesc(renderPassDesc); pipelineDesc.setRenderPassDesc(renderPassDesc);
gl::Rectangle renderArea; gl::Rectangle renderArea;
......
src/libANGLE/renderer/vulkan/vk_cache_utils.cpp
...@@ -488,13 +488,25 @@ bool GraphicsPipelineDesc::operator==(const GraphicsPipelineDesc &other) const ...@@ -488,13 +488,25 @@ bool GraphicsPipelineDesc::operator==(const GraphicsPipelineDesc &other) const
// TODO(jmadill): We should prefer using Packed GLenums. http://anglebug.com/2169 // TODO(jmadill): We should prefer using Packed GLenums. http://anglebug.com/2169
// Initialize PSO states, it is consistent with initial value of gl::State
void GraphicsPipelineDesc::initDefaults() void GraphicsPipelineDesc::initDefaults()
{ {
// Set all vertex input attributes to default, the default format is Float
angle::FormatID defaultFormat = GetCurrentValueFormatID(gl::VertexAttribType::Float);
for (PackedAttribDesc &packedAttrib : mVertexInputAttribs.attribs)
{
SetBitField(packedAttrib.stride, 0);
SetBitField(packedAttrib.divisor, 0);
SetBitField(packedAttrib.format, defaultFormat);
SetBitField(packedAttrib.offset, 0);
}
mRasterizationAndMultisampleStateInfo.bits.depthClampEnable = 0; mRasterizationAndMultisampleStateInfo.bits.depthClampEnable = 0;
mRasterizationAndMultisampleStateInfo.bits.rasterizationDiscardEnable = 0; mRasterizationAndMultisampleStateInfo.bits.rasterizationDiscardEnable = 0;
SetBitField(mRasterizationAndMultisampleStateInfo.bits.polygonMode, VK_POLYGON_MODE_FILL); SetBitField(mRasterizationAndMultisampleStateInfo.bits.polygonMode, VK_POLYGON_MODE_FILL);
SetBitField(mRasterizationAndMultisampleStateInfo.bits.cullMode, VK_CULL_MODE_NONE); SetBitField(mRasterizationAndMultisampleStateInfo.bits.cullMode, VK_CULL_MODE_BACK_BIT);
SetBitField(mRasterizationAndMultisampleStateInfo.bits.frontFace, VK_FRONT_FACE_CLOCKWISE); SetBitField(mRasterizationAndMultisampleStateInfo.bits.frontFace,
VK_FRONT_FACE_COUNTER_CLOCKWISE);
mRasterizationAndMultisampleStateInfo.bits.depthBiasEnable = 0; mRasterizationAndMultisampleStateInfo.bits.depthBiasEnable = 0;
mRasterizationAndMultisampleStateInfo.depthBiasConstantFactor = 0.0f; mRasterizationAndMultisampleStateInfo.depthBiasConstantFactor = 0.0f;
mRasterizationAndMultisampleStateInfo.depthBiasClamp = 0.0f; mRasterizationAndMultisampleStateInfo.depthBiasClamp = 0.0f;
...@@ -553,10 +565,10 @@ void GraphicsPipelineDesc::initDefaults() ...@@ -553,10 +565,10 @@ void GraphicsPipelineDesc::initDefaults()
PackedColorBlendAttachmentState blendAttachmentState; PackedColorBlendAttachmentState blendAttachmentState;
SetBitField(blendAttachmentState.srcColorBlendFactor, VK_BLEND_FACTOR_ONE); SetBitField(blendAttachmentState.srcColorBlendFactor, VK_BLEND_FACTOR_ONE);
SetBitField(blendAttachmentState.dstColorBlendFactor, VK_BLEND_FACTOR_ONE); SetBitField(blendAttachmentState.dstColorBlendFactor, VK_BLEND_FACTOR_ZERO);
SetBitField(blendAttachmentState.colorBlendOp, VK_BLEND_OP_ADD); SetBitField(blendAttachmentState.colorBlendOp, VK_BLEND_OP_ADD);
SetBitField(blendAttachmentState.srcAlphaBlendFactor, VK_BLEND_FACTOR_ONE); SetBitField(blendAttachmentState.srcAlphaBlendFactor, VK_BLEND_FACTOR_ONE);
SetBitField(blendAttachmentState.dstAlphaBlendFactor, VK_BLEND_FACTOR_ONE); SetBitField(blendAttachmentState.dstAlphaBlendFactor, VK_BLEND_FACTOR_ZERO);
SetBitField(blendAttachmentState.alphaBlendOp, VK_BLEND_OP_ADD); SetBitField(blendAttachmentState.alphaBlendOp, VK_BLEND_OP_ADD);
std::fill(&inputAndBlend.attachments[0], std::fill(&inputAndBlend.attachments[0],
...@@ -565,6 +577,19 @@ void GraphicsPipelineDesc::initDefaults() ...@@ -565,6 +577,19 @@ void GraphicsPipelineDesc::initDefaults()
inputAndBlend.primitive.topology = static_cast<uint16_t>(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST); inputAndBlend.primitive.topology = static_cast<uint16_t>(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST);
inputAndBlend.primitive.restartEnable = 0; inputAndBlend.primitive.restartEnable = 0;
// Viewport and scissor will be set to valid values when framebuffer being binded
mViewport.x = 0.0f;
mViewport.y = 0.0f;
mViewport.width = 0.0f;
mViewport.height = 0.0f;
mViewport.minDepth = 0.0f;
mViewport.maxDepth = 1.0f;
mScissor.offset.x = 0;
mScissor.offset.y = 0;
mScissor.extent.width = 0;
mScissor.extent.height = 0;
} }
angle::Result GraphicsPipelineDesc::initializePipeline( angle::Result GraphicsPipelineDesc::initializePipeline(
...@@ -876,11 +901,15 @@ void GraphicsPipelineDesc::updatePrimitiveRestartEnabled(GraphicsPipelineTransit ...@@ -876,11 +901,15 @@ void GraphicsPipelineDesc::updatePrimitiveRestartEnabled(GraphicsPipelineTransit
transition->set(ANGLE_GET_TRANSITION_BIT(mInputAssemblyAndColorBlendStateInfo, primitive)); transition->set(ANGLE_GET_TRANSITION_BIT(mInputAssemblyAndColorBlendStateInfo, primitive));
} }
void GraphicsPipelineDesc::setCullMode(VkCullModeFlagBits cullMode)
{
SetBitField(mRasterizationAndMultisampleStateInfo.bits.cullMode, cullMode);
}
void GraphicsPipelineDesc::updateCullMode(GraphicsPipelineTransitionBits *transition, void GraphicsPipelineDesc::updateCullMode(GraphicsPipelineTransitionBits *transition,
const gl::RasterizerState &rasterState) const gl::RasterizerState &rasterState)
{ {
mRasterizationAndMultisampleStateInfo.bits.cullMode = setCullMode(gl_vk::GetCullMode(rasterState));
static_cast<uint16_t>(gl_vk::GetCullMode(rasterState));
transition->set(ANGLE_GET_TRANSITION_BIT(mRasterizationAndMultisampleStateInfo, bits)); transition->set(ANGLE_GET_TRANSITION_BIT(mRasterizationAndMultisampleStateInfo, bits));
} }
......
src/libANGLE/renderer/vulkan/vk_cache_utils.h
...@@ -380,6 +380,7 @@ class GraphicsPipelineDesc final ...@@ -380,6 +380,7 @@ class GraphicsPipelineDesc final
bool primitiveRestartEnabled); bool primitiveRestartEnabled);
// Raster states // Raster states
void setCullMode(VkCullModeFlagBits cullMode);
void updateCullMode(GraphicsPipelineTransitionBits *transition, void updateCullMode(GraphicsPipelineTransitionBits *transition,
const gl::RasterizerState &rasterState); const gl::RasterizerState &rasterState);
void updateFrontFace(GraphicsPipelineTransitionBits *transition, void updateFrontFace(GraphicsPipelineTransitionBits *transition,
......
src/libANGLE/renderer/vulkan/vk_utils.cpp
...@@ -695,7 +695,7 @@ VkPrimitiveTopology GetPrimitiveTopology(gl::PrimitiveMode mode) ...@@ -695,7 +695,7 @@ VkPrimitiveTopology GetPrimitiveTopology(gl::PrimitiveMode mode)
} }
} }
VkCullModeFlags GetCullMode(const gl::RasterizerState &rasterState) VkCullModeFlagBits GetCullMode(const gl::RasterizerState &rasterState)
{ {
if (!rasterState.cullFace) if (!rasterState.cullFace)
{ {
......
src/libANGLE/renderer/vulkan/vk_utils.h
...@@ -575,7 +575,7 @@ VkFilter GetFilter(const GLenum filter); ...@@ -575,7 +575,7 @@ VkFilter GetFilter(const GLenum filter);
VkSamplerMipmapMode GetSamplerMipmapMode(const GLenum filter); VkSamplerMipmapMode GetSamplerMipmapMode(const GLenum filter);
VkSamplerAddressMode GetSamplerAddressMode(const GLenum wrap); VkSamplerAddressMode GetSamplerAddressMode(const GLenum wrap);
VkPrimitiveTopology GetPrimitiveTopology(gl::PrimitiveMode mode); VkPrimitiveTopology GetPrimitiveTopology(gl::PrimitiveMode mode);
VkCullModeFlags GetCullMode(const gl::RasterizerState &rasterState); VkCullModeFlagBits GetCullMode(const gl::RasterizerState &rasterState);
VkFrontFace GetFrontFace(GLenum frontFace, bool invertCullFace); VkFrontFace GetFrontFace(GLenum frontFace, bool invertCullFace);
VkSampleCountFlagBits GetSamples(GLint sampleCount); VkSampleCountFlagBits GetSamples(GLint sampleCount);
VkComponentSwizzle GetSwizzle(const GLenum swizzle); VkComponentSwizzle GetSwizzle(const GLenum swizzle);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment