void opengl_state::StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
if (face == GL_FRONT_AND_BACK) {
StencilOpSeparate(GL_FRONT, sfail, dpfail, dppass);
StencilOpSeparate(GL_BACK, sfail, dpfail, dppass);
return;
}
if (face == GL_FRONT) {
if (stencilOpFrontStencilFail == sfail && stencilOpFrontDepthFail == dpfail && stencilOpFrontPass == dppass) {
return;
}
glStencilOpSeparate(GL_FRONT, sfail, dpfail, dppass);
stencilOpFrontStencilFail = sfail;
stencilOpFrontDepthFail = dpfail;
stencilOpFrontPass = dppass;
} else {
if (stencilOpBackStencilFail == sfail && stencilOpBackDepthFail == dpfail && stencilOpBackPass == dppass) {
return;
}
glStencilOpSeparate(GL_BACK, sfail, dpfail, dppass);
stencilOpBackStencilFail = sfail;
stencilOpBackDepthFail = dpfail;
stencilOpBackPass = dppass;
}
}
void renderer_bind_stencil(struct renderer *r)
{
GLuint prog;
prog = r->null.prog;
glDepthMask(GL_FALSE);
glEnable(GL_STENCIL_TEST);
glDrawBuffer(GL_NONE);
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glClear(GL_STENCIL_BUFFER_BIT);
glStencilFunc(GL_ALWAYS, 0, 0);
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP);
glUseProgram(prog);
glUniformMatrix4fv(
glGetUniformLocation(prog, "ModelViewProjectionMatrix"),
1,
GL_FALSE,
r->mvp.a
);
glBindBuffer(GL_ARRAY_BUFFER, r->cube_attr);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, r->cube_idx);
glEnableVertexAttribArray(0);
glVertexAttribPointer(
0,
3,
GL_FLOAT,
GL_FALSE,
sizeof(struct attribs),
0
);
}
void VRSim::DSStencilPass(unsigned int PointLightIndex){
m_nullTech.enable();
// Disable color/depth write and enable stencil
m_gbuffer.BindForStencilPass();
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glClear(GL_STENCIL_BUFFER_BIT);
// We need the stencil test to be enabled but we want it
// to succeed always. Only the depth test matters.
glStencilFunc(GL_ALWAYS, 0, 0);
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP);
float BSphereScale = CalcPointLightBSphere(m_pointLight[PointLightIndex]);
sphere.model = cavr::math::mat4f::translate(m_pointLight[PointLightIndex].Position) * cavr::math::mat4f::scale(BSphereScale);
auto mvp = (cavr::gfx::getProjection() * cavr::gfx::getView() * sphere.model);
m_nullTech.set("gWVP", mvp);
sphere.renderModel();
}
void DeferredShading::mark_frustums(Slice<const Frustum> fs)
{
glEnable(GL_STENCIL_TEST);
glDisable(GL_CULL_FACE);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDepthMask(GL_FALSE);
DEFER {
glDisable(GL_STENCIL_TEST);
glEnable(GL_CULL_FACE);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glDepthMask(GL_TRUE);
};
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_REPLACE, GL_KEEP);
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_KEEP);
sun_shadow.bind();
glClear(GL_STENCIL_BUFFER_BIT);
BIND_SHADER(stencil);
for (int i = fs.length-1; i >= 0; i--) {
const Frustum &f = fs[i];
glStencilFunc(GL_ALWAYS, i+1, 0xFF);
draw_frustum(f);
}
}
void DSStencilPass(unsigned int PointLightIndex)
{
m_nullTech.Enable();
// Disable color/depth write and enable stencil
m_gbuffer.BindForStencilPass();
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glClear(GL_STENCIL_BUFFER_BIT);
// We need the stencil test to be enabled but we want it
// to succeed always. Only the depth test matters.
glStencilFunc(GL_ALWAYS, 0, 0);
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP);
Pipeline p;
p.WorldPos(m_pointLight[PointLightIndex].Position);
float BBoxScale = CalcPointLightBSphere(m_pointLight[PointLightIndex]);
p.Scale(BBoxScale, BBoxScale, BBoxScale);
p.SetCamera(m_pGameCamera->GetPos(), m_pGameCamera->GetTarget(), m_pGameCamera->GetUp());
p.SetPerspectiveProj(m_persProjInfo);
m_nullTech.SetWVP(p.GetWVPTrans());
m_bsphere.Render();
}
HQ_FORCE_INLINE void HQStateManagerGL::ActiveDepthStencilState(const HQSharedPtr<HQDepthStencilStateGL> &state)
{
if (state->depthEnable != this->dsState->depthEnable)
{
if (state->depthEnable)
glEnable(GL_DEPTH_TEST);
else
glDisable(GL_DEPTH_TEST);
}
if (state->depthFunc != this->dsState->depthFunc)
glDepthFunc(state->depthFunc);
if (state->depthWriteEnable != this->dsState->depthWriteEnable)
glDepthMask(state->depthWriteEnable);
if (state->stencilEnable != this->dsState->stencilEnable)
{
if (state->stencilEnable)
glEnable(GL_STENCIL_TEST);
else
glDisable(GL_STENCIL_TEST);
}
if (state->stencilEnable)
{
if (state->stwoSide)//two sided stencil
{
glStencilFuncSeparate(GL_FRONT ,
state->sfront.stencilFunc ,
state->sref,
state->sreadMask);
glStencilFuncSeparate(GL_BACK ,
state->sback.stencilFunc ,
state->sref,
state->sreadMask);
glStencilOpSeparate(GL_FRONT ,
state->sfront.stencilFailOp,
state->sfront.depthFailOp,
state->sfront.passOp);
glStencilOpSeparate(GL_BACK ,
state->sback.stencilFailOp,
state->sback.depthFailOp,
state->sback.passOp);
}//if (state->stwoSide)
else
{
glStencilFunc(state->sfront.stencilFunc ,
state->sref,
state->sreadMask);
glStencilOp(state->sfront.stencilFailOp,
state->sfront.depthFailOp,
state->sfront.passOp);
}
}//if (state->stencilEnable)
if (state->swriteMask != this->dsState->swriteMask)
glStencilMask(state->swriteMask);
}
void StateSystem::StencilState::applyGL() const
{
glStencilFuncSeparate(GL_FRONT, funcs[FACE_FRONT].func, funcs[FACE_FRONT].refvalue, funcs[FACE_FRONT].mask);
glStencilFuncSeparate(GL_BACK, funcs[FACE_BACK ].func, funcs[FACE_BACK ].refvalue, funcs[FACE_BACK ].mask);
glStencilOpSeparate(GL_FRONT, ops[FACE_FRONT].fail, ops[FACE_FRONT].zfail, ops[FACE_FRONT].zpass);
glStencilOpSeparate(GL_BACK, ops[FACE_BACK ].fail, ops[FACE_BACK ].zfail, ops[FACE_BACK ].zpass);
}
//creates a stencil which will determine how light is applied to fragments
//needs to be called before every light pass to ensure proper work
void DefRenderer::StencilPass(Camera *cam, Renderer *r)
{
ShaderProgram *temp = r->GetProgram();
r->SetShaderProgram(nullProg);
//only updating the stencil - no fragments drawn
glDrawBuffer(GL_NONE);
glEnable(GL_DEPTH_TEST);
//all the fragments need to be processed by the rasterizer
glDisable(GL_CULL_FACE);
glClear(GL_STENCIL_BUFFER_BIT);
glStencilFunc(GL_ALWAYS, 0, 0);
//if light is blocked - stencil 0
//if we pass through the light's front face and back face - stencil will be 0
//otherwise, something in the light area blocked from leaving the area, so it's 1
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP);
r->Ready();
mat4 mvp = cam->Get() * r->GetParentGO()->GetModelMatrix();
r->GetProgram()->SetUniform("MVP", value_ptr(mvp));
r->Render();
r->SetShaderProgram(temp);
}
void apply_Rstate_stencil( const Rstate_stencil* stencil ) {
if( stencil->enabled ) {
glEnable( GL_STENCIL_TEST );
glStencilFuncSeparate( GL_FRONT,
stencil->frontFunc,
stencil->frontRef,
stencil->frontMask );
glStencilFuncSeparate( GL_BACK,
stencil->backFunc,
stencil->backRef,
stencil->backMask );
glStencilOpSeparate( GL_FRONT,
stencil->frontFail,
stencil->frontZpass,
stencil->frontZfail );
glStencilOpSeparate( GL_BACK,
stencil->backFail,
stencil->backZpass,
stencil->backZfail );
} else
glDisable( GL_STENCIL_TEST );
}
void renderShadowInfoStencil(const MVP &boxMVP)
{
glDrawBuffer(GL_NONE);
glDepthMask(GL_FALSE);
glEnable(GL_DEPTH_CLAMP);
glDisable(GL_CULL_FACE);
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(1.0, 1.0);
glStencilFunc(GL_ALWAYS, 0, 0xff);
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP);
glUseProgram(shadowProgram.program);
glUniformMatrix4fv(shadowProgram.MVPMatrix, 1, GL_FALSE, boxMVP.modelViewProjMatrix.const_value_ptr());
glUniform3fv(shadowProgram.lightPosition, 1, pointLight.position.const_value_ptr());
pBoxMesh->Render();
glUseProgram(0);
glDisable(GL_DEPTH_CLAMP);
glEnable(GL_CULL_FACE);
glDepthMask(GL_TRUE);
glDisable(GL_POLYGON_OFFSET_FILL);
glDrawBuffer(GL_BACK);
}
//
// This is a static function used to A) turn on the stencil buffer and B) to
// set it's tests based on different front and back tests.
//
void Renderer::setStencilOp(const GLenum& frontDepthFail,
const GLenum& frontDepthPass, const GLenum& backDepthFail,
const GLenum& backDepthPass)
{
// Stencil operations for front and back faces differ.
glStencilOpSeparate(GL_FRONT, GL_KEEP, frontDepthFail, frontDepthPass);
glStencilOpSeparate(GL_BACK, GL_KEEP, backDepthFail, backDepthPass);
}
// GL 2.0 1-pass version
static void ss_GL2_1pass()
{
glDisable(GL_CULL_FACE);
glStencilMask(~0);
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_INCR_WRAP);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_DECR_WRAP);
glStencilFunc(GL_ALWAYS, 0, ~0);
pie_ShadowDrawLoop();
}
void ShadowVolume::draw(Vector4<float> lightPos, Vector3<float> cameraPos, const Vector3<float> *ownerVertex) {
Vector3<double> cameraPosD;
cameraPosD.x = (double)cameraPos.x;
cameraPosD.y = (double)cameraPos.y;
cameraPosD.z = (double)cameraPos.z;
calcShadowVolume(lightPos, ownerVertex, shadowPos, 8);
glDisable(GL_LIGHTING);
glDisable(GL_LIGHT0);
//ここからステンシルシャドウの処理
glEnable(GL_STENCIL_TEST);
glDepthMask(GL_FALSE);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glStencilFuncSeparate(GL_FRONT_AND_BACK, GL_ALWAYS, 0, ~0);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP);//表面は「+1」
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_DECR_WRAP);//裏面は「-1」
//シャドーボリュームを描画する
glBegin(GL_TRIANGLE_FAN);
glVertex3f(lightPos.x, lightPos.y, lightPos.z);
for(int loop = 0; loop < 3;++loop) {
glVertex3f(shadowPos[loop].x, shadowPos[loop].y, shadowPos[loop].z);
}
glVertex3f(shadowPos[0].x, shadowPos[0].y, shadowPos[0].z);
glEnd();
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glDepthMask(GL_TRUE);
glStencilFunc(GL_NOTEQUAL, 0, ~0); //ステンシル値が0じゃない部分が影
glStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
////ステンシルバッファを可視化
glPushMatrix();
//Tracball::getInstance().applyOfShadow();
glDepthMask(GL_FALSE);
glEnable(GL_BLEND); //ブレンド有効化
glColor4f(0.0f, 0.0f, 0.0f, 0.5f);
drawScreen(30, cameraPosD, 1); //スクリーン描画(fovy,znearをわたす)
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glDisable(GL_BLEND); //ブレンド無効化
glDepthMask(GL_TRUE);
glPopMatrix();
glDisable(GL_STENCIL_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
}
void PipelineImpl::setDepthStencilState(GlState& state) const
{
if(state.m_stateHashes.m_depthStencil == m_hashes.m_depthStencil)
{
return;
}
state.m_stateHashes.m_depthStencil = m_hashes.m_depthStencil;
// Depth
glDepthMask(m_in.m_depthStencil.m_depthWriteEnabled);
state.m_depthWriteMask = m_in.m_depthStencil.m_depthWriteEnabled;
if(m_cache.m_depthCompareFunction == GL_ALWAYS && !m_in.m_depthStencil.m_depthWriteEnabled)
{
glDisable(GL_DEPTH_TEST);
}
else
{
glEnable(GL_DEPTH_TEST);
}
glDepthFunc(m_cache.m_depthCompareFunction);
// Stencil
if(m_stencilTestEnabled)
{
glEnable(GL_STENCIL_TEST);
}
else
{
glDisable(GL_STENCIL_TEST);
}
glStencilOpSeparate(
GL_FRONT, m_cache.m_stencilFailOp[0], m_cache.m_stencilPassDepthFailOp[0], m_cache.m_stencilPassDepthPassOp[0]);
glStencilOpSeparate(
GL_BACK, m_cache.m_stencilFailOp[1], m_cache.m_stencilPassDepthFailOp[1], m_cache.m_stencilPassDepthPassOp[1]);
if(state.m_stencilCompareFunc[0] != m_cache.m_stencilCompareFunc[0])
{
state.m_stencilCompareFunc[0] = m_cache.m_stencilCompareFunc[0];
state.m_glStencilFuncSeparateDirtyMask |= 1 << 0;
}
if(state.m_stencilCompareFunc[1] != m_cache.m_stencilCompareFunc[1])
{
state.m_stencilCompareFunc[1] = m_cache.m_stencilCompareFunc[1];
state.m_glStencilFuncSeparateDirtyMask |= 1 << 1;
}
}
void LightPass::StencilTest()
{
m_gbuffer->BindForStencilPass();
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glClear(GL_STENCIL_BUFFER_BIT);
glStencilFunc(GL_ALWAYS, 0, 0);
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP);
}
//-----------------------------------------------------------------------------
void CPUTRenderStateBlockOGL::SetRenderStates( CPUTRenderParameters &renderParams )
{
//
// Set Depth and Stencil render states
//
mStateDesc.DepthStencilDesc.DepthEnable ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST);
mStateDesc.DepthStencilDesc.StencilEnable ? glEnable(GL_STENCIL_TEST) : glDisable(GL_STENCIL_TEST);
GL_CHECK("Set Depth Stencil States");
GL_CHECK(glDepthMask(mStateDesc.DepthStencilDesc.DepthWriteMask));
GL_CHECK(glDepthFunc(mStateDesc.DepthStencilDesc.DepthFunc));
GL_CHECK(glStencilMaskSeparate(GL_FRONT_AND_BACK, mStateDesc.DepthStencilDesc.StencilWriteMask));
GL_CHECK(glStencilOpSeparate(GL_FRONT, mStateDesc.DepthStencilDesc.FrontFaceStencilFailOp, mStateDesc.DepthStencilDesc.FrontFaceStencilDepthFailOp, mStateDesc.DepthStencilDesc.FrontFaceStencilPassOp));
GL_CHECK(glStencilOpSeparate(GL_BACK, mStateDesc.DepthStencilDesc.BackFaceStencilFailOp, mStateDesc.DepthStencilDesc.BackFaceStencilDepthFailOp, mStateDesc.DepthStencilDesc.BackFaceStencilPassOp));
GL_CHECK(glStencilFuncSeparate(GL_FRONT, mStateDesc.DepthStencilDesc.FrontFaceStencilFunc, mStateDesc.DepthStencilDesc.FrontFaceStencilFuncRef, mStateDesc.DepthStencilDesc.FrontFaceStencilFuncMask));
GL_CHECK(glStencilFuncSeparate(GL_BACK, mStateDesc.DepthStencilDesc.BackFaceStencilFunc, mStateDesc.DepthStencilDesc.BackFaceStencilFuncRef, mStateDesc.DepthStencilDesc.BackFaceStencilFuncMask));
//
// Set Rasterization states
//
#ifndef CPUT_FOR_OGLES
GL_CHECK(glPolygonMode(GL_FRONT_AND_BACK, mStateDesc.RasterizerDesc.FillMode));
#endif
GL_CHECK(glCullFace(mStateDesc.RasterizerDesc.CullMode));
GL_CHECK(glFrontFace(mStateDesc.RasterizerDesc.FrontCounterClockwise));
//GL_CHECK(glPolygonOffset()); // used for depth bias
mStateDesc.RasterizerDesc.CullingEnabled ? glEnable(GL_CULL_FACE) : glDisable(GL_CULL_FACE);
mStateDesc.RasterizerDesc.ScissorEnable ? glEnable(GL_SCISSOR_TEST) : glDisable(GL_SCISSOR_TEST); // is glScissor needed here as well?
#ifndef CPUT_FOR_OGLES
mStateDesc.RasterizerDesc.DepthClipEnable ? glDisable(GL_DEPTH_CLAMP) : glEnable(GL_DEPTH_CLAMP);
mStateDesc.RasterizerDesc.MultisampleEnable ? glEnable(GL_MULTISAMPLE) : glDisable(GL_MULTISAMPLE); // is glSampleCoverage() needed here as well?
mStateDesc.RasterizerDesc.AntialiasedLineEnable ? glEnable(GL_LINE_SMOOTH) : glDisable(GL_LINE_SMOOTH);
//NOTE: Could not find the rendertarget being set to SRGB anywhere else; this might not be the best place
GL_CHECK(glEnable(GL_FRAMEBUFFER_SRGB));
#endif
GL_CHECK("Set Rasterization States");
//glDisable(GL_CULL_FACE);
//
// Set Blend states
//
mStateDesc.RenderTargetBlendDesc.BlendEnable ? glEnable(GL_BLEND): glDisable(GL_BLEND);
GL_CHECK(glBlendFuncSeparate(mStateDesc.RenderTargetBlendDesc.SrcBlend,mStateDesc.RenderTargetBlendDesc.DestBlend,mStateDesc.RenderTargetBlendDesc.SrcBlendAlpha,mStateDesc.RenderTargetBlendDesc.DestBlendAlpha));
GL_CHECK(glBlendEquationSeparate(mStateDesc.RenderTargetBlendDesc.BlendOp,mStateDesc.RenderTargetBlendDesc.BlendOpAlpha));
GL_CHECK("Set Blend States");
} // CPUTRenderStateBlockOGL::SetRenderState()
void CG3DGraphicsGL::ApplyStencil(CG3DStencilSet* set)
{
GLenum face;
switch (set->m_Face) {
case CG3DStencilSet::FRONT: face = GL_FRONT; break;
case CG3DStencilSet::BACK: face = GL_BACK; break;
case CG3DStencilSet::FRONT_AND_BACK: face = GL_FRONT_AND_BACK; break;
}
glStencilMaskSeparate(face, set->m_Mask);
switch (set->m_Func) {
case CG3DStencilSet::ALWAYS: glDisable(GL_STENCIL_TEST); break;
case CG3DStencilSet::NEVER: glEnable(GL_STENCIL_TEST); glStencilFuncSeparate(face, GL_NEVER, set->m_FuncRef, set->m_FuncMask); break;
case CG3DStencilSet::LESS: glEnable(GL_STENCIL_TEST); glStencilFuncSeparate(face, GL_LESS, set->m_FuncRef, set->m_FuncMask); break;
case CG3DStencilSet::LEQUAL: glEnable(GL_STENCIL_TEST); glStencilFuncSeparate(face, GL_LEQUAL, set->m_FuncRef, set->m_FuncMask); break;
case CG3DStencilSet::EQUAL: glEnable(GL_STENCIL_TEST); glStencilFuncSeparate(face, GL_EQUAL, set->m_FuncRef, set->m_FuncMask); break;
case CG3DStencilSet::GREATER: glEnable(GL_STENCIL_TEST); glStencilFuncSeparate(face, GL_GREATER, set->m_FuncRef, set->m_FuncMask); break;
case CG3DStencilSet::GEQUAL: glEnable(GL_STENCIL_TEST); glStencilFuncSeparate(face, GL_GEQUAL, set->m_FuncRef, set->m_FuncMask); break;
case CG3DStencilSet::NOTEQUAL: glEnable(GL_STENCIL_TEST); glStencilFuncSeparate(face, GL_NOTEQUAL, set->m_FuncRef, set->m_FuncMask); break;
}
glStencilOpSeparate(face, GetOp(set->m_StencilFail), GetOp(set->m_DepthFail), GetOp(set->m_DepthPass));
if (set->m_OtherFace != NULL)
ApplyStencil(set->m_OtherFace);
}
/*************************************************************//**
*
* @brief ステンシルの関数の設定を行う
* @param 関数の種類
* @param 比較値
* @param マスク
* @param 面
* @return なし
*
****************************************************************/
void C_OpenGlManager::SetStencilProcess(StencilEnum stencilFail,
StencilEnum stencilPassAndDepthFail,
StencilEnum stencilPassAndDepthPass,
FaceEnum face)
{
glStencilOpSeparate(face, stencilFail, stencilPassAndDepthFail, stencilPassAndDepthPass);
}
//--------------------------------------------------------------
// start drawing decal background. draw=false just sets depth
void mgGL33Services::decalBackground(
BOOL draw)
{
CHECK_THREAD();
// set the stencil buffer based on depth test
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_ALWAYS, 1, 1);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_ZERO, GL_REPLACE);
glStencilOpSeparate(GL_BACK, GL_ZERO, GL_ZERO, GL_ZERO);
// if we shouldn't draw the background, turn off write of color
if (!draw)
{
glDepthFunc(GL_LEQUAL);
glColorMask(false, false, false, false);
}
}
void GBuffer::bindForStencilPass() {
glDrawBuffer(GL_NONE); // disable draw buffer as we don't want to be drawing to the depth buffer or anything else
// we only want to affect the stencil buffer
glEnable(GL_STENCIL_TEST);
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glStencilFunc(GL_ALWAYS, 0, 0); // always pass stencil
// first param (GL_KEEP) is when stencil test fails - it's set to always pass, so is irrelevant
// second param is when stencil passes, but depth test fails - we want to increment/decrement
// third param is when stencil passes and depth test passes (means vertex is completely outside of volume (behind)
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR, GL_KEEP);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR, GL_KEEP);
}
void NGLScene::renderLightPass(const std::string &_shader)
{
// get the VBO instance and draw the built in teapot
ngl::VAOPrimitives *prim=ngl::VAOPrimitives::instance();
ngl::ShaderLib *shader = ngl::ShaderLib::instance();
glDrawBuffer(GL_NONE);
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glClear(GL_STENCIL_BUFFER_BIT);
glStencilFunc(GL_ALWAYS, 0, 0);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP);
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP);
shader->use(_shader);
for(float z=-5.0; z<5.0; z+=0.5)
{
for(float x=-5.0; x<5.0; x+=0.5)
{
m_transform.reset();
m_transform.setPosition(x,sin(x),z);
ngl::Mat4 MV;
ngl::Mat4 MVP;
ngl::Mat4 M;
M=m_transform.getMatrix()*m_mouseGlobalTX;
MV= M*m_cam.getViewMatrix();
MVP= MV*m_cam.getProjectionMatrix();
ngl::Mat4 globalMV = MV.transpose();
ngl::Vec4 p(x,sin(x),z,1.0f);
p=globalMV*p;
shader->setShaderParam3f("lightPos",p.m_x,p.m_y,p.m_z);
shader->setShaderParamFromMat4("MVP",MVP);
prim->draw("lightSphere");
}
}
glDisable(GL_BLEND);
glDisable(GL_CULL_FACE);
}
static void glnvg__fill(GLNVGcontext* gl, GLNVGcall* call)
{
PROFILER_CPU_TIMESLICE("NVG backend fill");
GLNVGpath* paths = &gl->paths[call->pathOffset];
int i, npaths = call->pathCount;
// Draw shapes
glEnable(GL_STENCIL_TEST);
glStencilMask(0xff);
glStencilFunc(GL_ALWAYS, 0, 0xff);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
// set bindpoint for solid loc
glnvg__setUniforms(gl, call->uniformOffset, 0);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP);
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_DECR_WRAP);
glDisable(GL_CULL_FACE);
for (i = 0; i < npaths; i++)
glDrawArrays(GL_TRIANGLE_FAN, paths[i].fillOffset, paths[i].fillCount);
glEnable(GL_CULL_FACE);
// Draw anti-aliased pixels
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glnvg__setUniforms(gl, call->uniformOffset + gl->fragSize, call->image);
if (gl->flags & NVG_ANTIALIAS) {
glStencilFunc(GL_EQUAL, 0x00, 0xff);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
// Draw fringes
for (i = 0; i < npaths; i++)
glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);
}
// Draw fill
glStencilFunc(GL_NOTEQUAL, 0x0, 0xff);
glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
glDrawArrays(GL_TRIANGLES, call->triangleOffset, call->triangleCount);
glDisable(GL_STENCIL_TEST);
}
inline void VL_glStencilOpSeparate( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
if (glStencilOpSeparate)
glStencilOpSeparate( face, sfail, dpfail, dppass );
else
VL_UNSUPPORTED_FUNC();
// NOT SUPPORTED
// see also http://www.opengl.org/registry/specs/ATI/separate_stencil.txt
/*else
if ( Has_GL_ATI_separate_stencil )
glStencilOpSeparateATI( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass )*/
}
void StencilPass::startPass(CGraphics* it, PointLight* Light) {
m_shaderProg.useProgram();
// Disable color/depth write and enable stencil
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glClear(GL_STENCIL_BUFFER_BIT);
// We need the stencil test to be enabled but we want it
// to succeed always. Only the depth test matters.
glStencilFunc(GL_ALWAYS, 0, 0);
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP);
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP);
Pipeline::position(it->getOwner()->GetTransform()->getPosition().x, it->getOwner()->GetTransform()->getPosition().y, it->getOwner()->GetTransform()->getPosition().z);
float BSphereScale = CalcPointLightBSphere(Light);
Pipeline::scale(BSphereScale, BSphereScale, BSphereScale);
glUniformMatrix4fv(m_MVPLocation, 1, GL_FALSE, &Pipeline::getTransformationMatrix()[0][0]);
}
void device_stencilop(device_t device, enum gs_stencil_side side,
enum gs_stencil_op fail, enum gs_stencil_op zfail,
enum gs_stencil_op zpass)
{
GLenum gl_side = convert_gs_stencil_side(side);
GLenum gl_fail = convert_gs_stencil_op(fail);
GLenum gl_zfail = convert_gs_stencil_op(zfail);
GLenum gl_zpass = convert_gs_stencil_op(zpass);
glStencilOpSeparate(gl_side, gl_fail, gl_zfail, gl_zpass);
if (!gl_success("glStencilOpSeparate"))
blog(LOG_ERROR, "device_stencilop (GL) failed");
}
void GLState::glsStencilOpSeparate(const GLenum face, const GLenum sfail,
const GLenum dpfail, const GLenum dppass) {
switch (face) {
case GL_FRONT_AND_BACK:
/*
if (setGLenumGLenum(GL_STENCIL_FAIL, sfail) || // Front
setGLenumGLenum(GL_STENCIL_PASS_DEPTH_FAIL, dpfail) || // Front
setGLenumGLenum(GL_STENCIL_PASS_DEPTH_PASS, dppass) || // Front
setGLenumGLenum(GL_STENCIL_BACK_FAIL, sfail) || // back
setGLenumGLenum(GL_STENCIL_BACK_PASS_DEPTH_FAIL, sfail) || // back
setGLenumGLenum(GL_STENCIL_BACK_PASS_DEPTH_PASS, sfail)) { // back
glStencilOpSeparate(GL_FRONT_AND_BACK, sfail, dpfail, dppass);
ERROR_CHECK;
}
*/
glsStencilOpSeparate(GL_FRONT, sfail, dpfail, dppass);
glsStencilOpSeparate(GL_BACK, sfail, dpfail, dppass);
break;
case GL_FRONT:
if (setGLenum(GL_STENCIL_FAIL, &sfail, GLTYPE_ENUM_SIZE, GLTYPE_ENUM) ||
setGLenum(GL_STENCIL_PASS_DEPTH_FAIL, &dpfail, GLTYPE_ENUM_SIZE, GLTYPE_ENUM) ||
setGLenum(GL_STENCIL_PASS_DEPTH_PASS, &dppass, GLTYPE_ENUM_SIZE, GLTYPE_ENUM)) {
glStencilOpSeparate(GL_FRONT, sfail, dpfail, dppass);
ERROR_CHECK;
}
break;
case GL_BACK:
if (setGLenum(GL_STENCIL_BACK_FAIL, &sfail, GLTYPE_ENUM_SIZE, GLTYPE_ENUM) ||
setGLenum(GL_STENCIL_BACK_PASS_DEPTH_FAIL, &dpfail, GLTYPE_ENUM_SIZE, GLTYPE_ENUM) ||
setGLenum(GL_STENCIL_BACK_PASS_DEPTH_PASS, &dppass, GLTYPE_ENUM_SIZE, GLTYPE_ENUM)) {
glStencilOpSeparate(GL_BACK, sfail, dpfail, dppass);
ERROR_CHECK;
}
break;
default:
throw std::runtime_error("GLState::glsStencilOpSeparate() - face"
" invalid");
}
}
void OpenGLDepthStencilState::apply()
{
if (changed_desc)
{
changed_desc = false;
if (glStencilFuncSeparate)
{
CompareFunction front; int front_ref; int front_mask;
CompareFunction back; int back_ref; int back_mask;
unsigned char front_facing_mask, back_facing_mask;
StencilOp fail_front, pass_depth_fail_front, pass_depth_pass_front;
StencilOp fail_back, pass_depth_fail_back, pass_depth_pass_back;
desc.get_stencil_compare_front(front, front_ref, front_mask);
desc.get_stencil_compare_back(back, back_ref, back_mask);
desc.get_stencil_write_mask(front_facing_mask, back_facing_mask);
desc.get_stencil_op_front(fail_front, pass_depth_fail_front, pass_depth_pass_front);
desc.get_stencil_op_back(fail_back, pass_depth_fail_back, pass_depth_pass_back);
desc.is_stencil_test_enabled() ? glEnable(GL_STENCIL_TEST) : glDisable(GL_STENCIL_TEST);
glStencilFuncSeparate(GL_FRONT, OpenGL::to_enum(front), front_ref, front_mask);
glStencilFuncSeparate(GL_BACK, OpenGL::to_enum(back), back_ref, back_mask);
glStencilMaskSeparate(GL_FRONT, front_facing_mask);
glStencilMaskSeparate(GL_BACK, back_facing_mask);
glStencilOpSeparate(GL_FRONT, OpenGL::to_enum(fail_front), OpenGL::to_enum(pass_depth_fail_front), OpenGL::to_enum(pass_depth_pass_front));
glStencilOpSeparate(GL_BACK, OpenGL::to_enum(fail_back), OpenGL::to_enum(pass_depth_fail_back), OpenGL::to_enum(pass_depth_pass_back));
}
desc.is_depth_test_enabled() ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST);
glDepthMask(desc.is_depth_write_enabled() ? 1 : 0);
glDepthFunc(OpenGL::to_enum(desc.get_depth_compare_function()));
}
}
void device_stencil_op(gs_device_t device, enum gs_stencil_side side,
enum gs_stencil_op_type fail, enum gs_stencil_op_type zfail,
enum gs_stencil_op_type zpass)
{
GLenum gl_side = convert_gs_stencil_side(side);
GLenum gl_fail = convert_gs_stencil_op(fail);
GLenum gl_zfail = convert_gs_stencil_op(zfail);
GLenum gl_zpass = convert_gs_stencil_op(zpass);
glStencilOpSeparate(gl_side, gl_fail, gl_zfail, gl_zpass);
if (!gl_success("glStencilOpSeparate"))
blog(LOG_ERROR, "device_stencil_op (GL) failed");
UNUSED_PARAMETER(device);
}
static int StencilOp(lua_State *L)
{
GLenum face;
GLenum sfail = checkstencilop(L, 1);
GLenum dpfail = checkstencilop(L, 2);
GLenum dppass = checkstencilop(L, 3);
if(lua_isstring(L, 4))
{
face = checkface(L, 4);
glStencilOpSeparate(face, sfail, dpfail, dppass);
}
else
glStencilOp(sfail, dpfail, dppass);
CheckError(L);
return 0;
}
void OpenGLES2Context::setStencilActions(TriangleFace triangleFace, CompareMode compareMode, StencilAction actionOnBothPass, StencilAction actionOnDepthFail, StencilAction actionOnDepthPassStencilFail)
{
if (compareMode != m_curStencilFunc)
{
m_curStencilFunc = compareMode;
glStencilFuncSeparate(m_triangleFaces[triangleFace], m_compareFuncs[compareMode], m_curStencilRef, m_curStencilMask);
}
if (actionOnBothPass != m_curStencilBothPassOp || actionOnDepthFail != m_curStencilDepthFailOp || actionOnDepthPassStencilFail != m_curStencilDepthPassStencilFailOp)
{
m_curStencilBothPassOp = actionOnBothPass;
m_curStencilDepthFailOp = actionOnDepthFail;
m_curStencilDepthPassStencilFailOp = actionOnDepthPassStencilFail;
glStencilOpSeparate(m_triangleFaces[triangleFace], m_stencilActions[actionOnDepthFail], m_stencilActions[actionOnDepthPassStencilFail], m_stencilActions[actionOnBothPass]);
}
}