bool initGL() { glewInit(); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glDepthMask(true); glFrontFace(GL_CCW); glCullFace(GL_BACK); glEnable(GL_DEPTH_TEST); glClearDepth(1.0f); glClearStencil(0); glShadeModel(GL_SMOOTH); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glReadBuffer(GL_BACK); glDrawBuffer(GL_BACK); glDisable(GL_STENCIL_TEST); glStencilMask(0xFFFFFFFF); glStencilFunc(GL_EQUAL, 0x00000000, 0x00000001); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glFrontFace(GL_CCW); glCullFace(GL_BACK); //glEnable(GL_CULL_FACE); glDisable(GL_BLEND); glDisable(GL_ALPHA_TEST); glDisable(GL_DITHER); if(!glewIsSupported("GL_VERSION_2_0")) { LOG("your system does not support open gl shader model 2"); return false; } // init shader volcanoShaderProgram = new ShaderProgram(); volcanoShaderProgram->addShaderFromSource(ShaderProgram::SHADER_VERTEX, "./media/shader/volcano.vs"); volcanoShaderProgram->addShaderFromSource(ShaderProgram::SHADER_FRAGMENT, "./media/shader/volcano.fs"); if(!volcanoShaderProgram->link()) { LOG("volcano shader linkage error"); return false; } return true; }
void SkGLWidget::createRenderTarget() { if (!fCurContext) { return; } glDisable(GL_SCISSOR_TEST); glStencilMask(0xffffffff); glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); fCurContext->resetContext(); GrBackendRenderTargetDesc desc = this->getDesc(this->width(), this->height()); desc.fOrigin = kBottomLeft_GrSurfaceOrigin; fGpuSurface = SkSurface::MakeFromBackendRenderTarget(fCurContext.get(), desc, nullptr); fCanvas = fGpuSurface->getCanvas(); }
void GSDeviceOGL::CreateTextureFX() { GL_PUSH("CreateTextureFX"); m_vs_cb = new GSUniformBufferOGL(g_vs_cb_index, sizeof(VSConstantBuffer)); m_ps_cb = new GSUniformBufferOGL(g_ps_cb_index, sizeof(PSConstantBuffer)); // warning 1 sampler by image unit. So you cannot reuse m_ps_ss... m_palette_ss = CreateSampler(false, false, false); gl_BindSampler(1, m_palette_ss); // Pre compile all Geometry & Vertex Shader // It might cost a seconds at startup but it would reduce benchmark pollution m_gs = CompileGS(); int logz = theApp.GetConfig("logz", 1); // Don't do it in debug build, so it can still be tested #ifndef _DEBUG if (GLLoader::found_GL_ARB_clip_control && logz) { fprintf(stderr, "Your driver supports advance depth. Logz will be disabled\n"); logz = 0; } else if (!GLLoader::found_GL_ARB_clip_control && !logz) { fprintf(stderr, "Your driver DOESN'T support advance depth (GL_ARB_clip_control)\n It is higly recommmended to enable logz\n"); } #endif for (uint32 key = 0; key < VSSelector::size(); key++) { // wildhack is only useful if both TME and FST are enabled. VSSelector sel(key); if (sel.wildhack && (!sel.tme || !sel.fst)) m_vs[key] = 0; else m_vs[key] = CompileVS(sel, logz); } // Enable all bits for stencil operations. Technically 1 bit is // enough but buffer is polluted with noise. Clear will be limited // to the mask. glStencilMask(0xFF); for (uint32 key = 0; key < OMDepthStencilSelector::size(); key++) m_om_dss[key] = CreateDepthStencil(OMDepthStencilSelector(key)); // Help to debug FS in apitrace m_apitrace = CompilePS(PSSelector()); GL_POP(); }
void ClippingNode::onAfterVisit() { /////////////////////////////////// // CLEANUP // manually restore the stencil state glStencilFunc(_currentStencilFunc, _currentStencilRef, _currentStencilValueMask); glStencilOp(_currentStencilFail, _currentStencilPassDepthFail, _currentStencilPassDepthPass); glStencilMask(_currentStencilWriteMask); if (!_currentStencilEnabled) { glDisable(GL_STENCIL_TEST); } // we are done using this layer, decrement s_layer--; }
void SkGLWidget::initializeGL() { fCurIntf = GrGLCreateNativeInterface(); if (!fCurIntf) { return; } glStencilMask(0xffffffff); glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); fCurContext = GrContext::Create(kOpenGL_GrBackend, (GrBackendContext) fCurIntf); GrBackendRenderTargetDesc desc = this->getDesc(this->width(), this->height()); desc.fOrigin = kBottomLeft_GrSurfaceOrigin; GrRenderTarget* curRenderTarget = fCurContext->wrapBackendRenderTarget(desc); fGpuDevice = SkGpuDevice::Create(curRenderTarget); fCanvas = new SkCanvas(fGpuDevice); curRenderTarget->unref(); }
static void pie_DrawShadows(void) { const float width = pie_GetVideoBufferWidth(); const float height = pie_GetVideoBufferHeight(); pie_SetTexturePage(TEXPAGE_NONE); glPushMatrix(); pie_SetAlphaTest(false); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDepthFunc(GL_LESS); glDepthMask(GL_FALSE); glEnable(GL_STENCIL_TEST); ShadowStencilFunc(); pie_SetRendMode(REND_ALPHA); glEnable(GL_CULL_FACE); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glStencilMask(~0); glStencilFunc(GL_LESS, 0, ~0); glColor4f(0, 0, 0, 0.5); pie_PerspectiveEnd(); glLoadIdentity(); glDisable(GL_DEPTH_TEST); glBegin(GL_TRIANGLE_STRIP); glVertex2f(0, 0); glVertex2f(width, 0); glVertex2f(0, height); glVertex2f(width, height); glEnd(); pie_PerspectiveBegin(); pie_SetRendMode(REND_OPAQUE); glDisable(GL_STENCIL_TEST); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glPopMatrix(); scshapes.clear(); }
static void glnvg__stroke(GLNVGcontext* gl, GLNVGcall* call) { PROFILER_CPU_TIMESLICE("NVG backend stroke"); GLNVGpath* paths = &gl->paths[call->pathOffset]; int npaths = call->pathCount, i; if (gl->flags & NVG_STENCIL_STROKES) { glEnable(GL_STENCIL_TEST); glStencilMask(0xff); // Fill the stroke base without overlap glStencilFunc(GL_EQUAL, 0x0, 0xff); glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); glnvg__setUniforms(gl, call->uniformOffset + gl->fragSize, call->image); for (i = 0; i < npaths; i++) glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount); // Draw anti-aliased pixels. glnvg__setUniforms(gl, call->uniformOffset, call->image); glStencilFunc(GL_EQUAL, 0x00, 0xff); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); for (i = 0; i < npaths; i++) glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount); // Clear stencil buffer. glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glStencilFunc(GL_ALWAYS, 0x0, 0xff); glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO); for (i = 0; i < npaths; i++) glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDisable(GL_STENCIL_TEST); // glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset + gl->fragSize), paint, scissor, strokeWidth, fringe, 1.0f - 0.5f/255.0f); } else { // Draw Strokes glnvg__setUniforms(gl, call->uniformOffset, call->image); for (i = 0; i < npaths; i++) glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount); } }
void DeferredShadingMSAA::PerformDualPassLighting_PerPixel() { glBindFramebuffer(GL_FRAMEBUFFER, getMainFBO()); glDisable(GL_DEPTH_TEST); m_shaderLighting->enable(); // Pass our current matrices to the shader m_shaderLighting->setUniformMatrix4fv("uProjViewMatrix", inverse(m_proj)._array); m_shaderLighting->setUniformMatrix4fv("uViewWorldMatrix", inverse(m_transformer->getModelViewMat())._array); // Pass all of the parameters that define our lighting and MSAA mode to the shader m_shaderLighting->setUniform1i("uSeparateEdgePass", m_bSeparateComplexPass); m_shaderLighting->setUniform1i("uUseDiscontinuity", (m_approach == APPROACH_DISCONTINUITY)); m_shaderLighting->setUniform1i("uAdaptiveShading", m_bAdaptiveShading); m_shaderLighting->setUniform1i("uShowComplexPixels", m_bMarkComplexPixels); m_shaderLighting->setUniform1i("uLightingModel", m_brdf); m_shaderLighting->setUniform1i("uMSAACount", m_iMSAACount); m_shaderLighting->setUniform1i("uSampleMask", (1 << m_iMSAACount) - 1); // Use our G-Buffer as source textures m_shaderLighting->bindTexture2DMultisample("uTexGBuffer1", 0, m_texGBuffer[0]); m_shaderLighting->bindTexture2DMultisample("uTexGBuffer2", 1, m_texGBuffer[1]); m_shaderLighting->bindTexture2DMultisample("uTexCoverage", 2, m_texGBuffer[2]); // Provide the resolved non-MSAA color buffer so the shader can use it for certain lighting modes m_shaderLighting->bindTextureRect("uResolvedColorBuffer", 3, m_texGBufResolved2); glEnable(GL_STENCIL_TEST); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glStencilMask(0x00); // Disable writing to the stencil mask // Render First (Simple Pixel) Pass glStencilFunc(GL_EQUAL, 1, 0xFF); m_shaderLighting->setUniform1i("uSecondPass", GL_FALSE); RenderFullscreenQuad(m_shaderLighting); // Render Second (Complex Pixel) Pass glStencilFunc(GL_EQUAL, 0, 0xFF); m_shaderLighting->setUniform1i("uSecondPass", GL_TRUE); RenderFullscreenQuad(m_shaderLighting); m_shaderLighting->disable(); }
// generic 2-pass version static void ss_2pass() { glStencilMask(~0); glStencilFunc(GL_ALWAYS, 0, ~0); glEnable(GL_CULL_FACE); // Setup stencil for front-facing polygons glCullFace(GL_BACK); glStencilOp(GL_KEEP, GL_KEEP, ss_op_depth_pass_front); pie_ShadowDrawLoop(); // Setup stencil for back-facing polygons glCullFace(GL_FRONT); glStencilOp(GL_KEEP, GL_KEEP, ss_op_depth_pass_back); pie_ShadowDrawLoop(); }
void StencilScopeOGL::applySettings(const StencilSettings& settings) { if(settings.enabled()) { glEnable(GL_STENCIL_TEST); glStencilOpSeparate(convert_face(settings.face()), convert_stencil_op(settings.sfail()), convert_stencil_op(settings.dpfail()), convert_stencil_op(settings.dppass())); glStencilFuncSeparate(convert_face(settings.face()), convert_func(settings.func()), settings.ref(), settings.ref_mask()); glStencilMaskSeparate(convert_face(settings.face()), settings.mask()); } else { glDisable(GL_STENCIL_TEST); glStencilMask(0); } }
void Graphics::SetStencilTest(bool enable, GLuint writeMask, GLenum sfail, GLenum dpfail, GLenum dppass, GLenum func, GLint ref, GLuint compareMask) { static bool enable_ = DEFAULT_STENCIL_ENABLE; static GLuint writeMask_ = DEFAULT_STENCIL_WRITEMASK; static GLenum sfail_ = DEFAULT_STENCIL_SFAIL; static GLenum dpfail_ = DEFAULT_STENCIL_DPFAIL; static GLenum dppass_ = DEFAULT_STENCIL_DPPASS; static GLenum func_ = DEFAULT_STENCIL_FUNC; static GLint ref_ = DEFAULT_STENCIL_REF; static GLuint compareMask_ = DEFAULT_STENCIL_COMPAREMASK; if (enable != enable_) { if (enable) glEnable(GL_STENCIL_TEST); else glDisable(GL_STENCIL_TEST); enable_ = enable; } if (enable) { if (func != func_ || ref != ref_ || compareMask != compareMask_) { glStencilFunc(func, ref, compareMask); func_ = func; ref_ = ref; compareMask_ = compareMask; } if (writeMask != writeMask_) { glStencilMask(writeMask); writeMask_ = writeMask; } if (sfail != sfail_ || dpfail != dpfail_ || dppass != dppass_) { glStencilOp(sfail, dpfail, dppass); sfail_ = sfail; dpfail_ = dpfail; dppass_ = dppass; } } }
GFX::GFX() : matrix_mode(MODELVIEW_MATRIX) { #ifdef __IPHONE_4_0 printf("\nGL_VENDOR: %s\n", ( char * )glGetString( GL_VENDOR ) ); printf("GL_RENDERER: %s\n" , ( char * )glGetString( GL_RENDERER ) ); printf("GL_VERSION: %s\n" , ( char * )glGetString( GL_VERSION ) ); printf("GL_EXTENSIONS: %s\n" , ( char * )glGetString( GL_EXTENSIONS ) ); #else __android_log_print( ANDROID_LOG_INFO, "", "\nGL_VENDOR: %s\n", ( char * )glGetString( GL_VENDOR ) ); __android_log_print( ANDROID_LOG_INFO, "", "GL_RENDERER: %s\n" , ( char * )glGetString( GL_RENDERER ) ); __android_log_print( ANDROID_LOG_INFO, "", "GL_VERSION: %s\n" , ( char * )glGetString( GL_VERSION ) ); __android_log_print( ANDROID_LOG_INFO, "", "GL_EXTENSIONS: %s\n" , ( char * )glGetString( GL_EXTENSIONS ) ); #endif glHint( GL_GENERATE_MIPMAP_HINT, GL_NICEST ); glHint( GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES, GL_NICEST ); glEnable( GL_DEPTH_TEST ); glEnable( GL_CULL_FACE ); glDisable( GL_DITHER ); glDepthMask( GL_TRUE ); glDepthFunc( GL_LESS ); glDepthRangef( 0.0f, 1.0f ); glCullFace ( GL_BACK ); glFrontFace( GL_CCW ); glClearStencil( 0 ); glStencilMask( 0xFFFFFFFF ); glClearColor( 0.0f, 0.0f, 0.0f, 1.0f ); glClear( GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT ); #ifndef __IPHONE_4_0 glBindVertexArrayOES = ( PFNGLBINDVERTEXARRAYOESPROC ) eglGetProcAddress("glBindVertexArrayOES" ); glGenVertexArraysOES = ( PFNGLGENVERTEXARRAYSOESPROC ) eglGetProcAddress("glGenVertexArraysOES" ); glDeleteVertexArraysOES = ( PFNGLDELETEVERTEXARRAYSOESPROC ) eglGetProcAddress("glDeleteVertexArraysOES"); #endif }
void SkGLWidget::resizeGL(int w, int h) { if (fCurContext) { glDisable(GL_SCISSOR_TEST); glStencilMask(0xffffffff); glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); fCurContext->resetContext(); GrBackendRenderTargetDesc desc = this->getDesc(w, h); desc.fOrigin = kBottomLeft_GrSurfaceOrigin; GrRenderTarget* curRenderTarget = fCurContext->wrapBackendRenderTarget(desc); SkSafeUnref(fGpuDevice); SkSafeUnref(fCanvas); fGpuDevice = SkGpuDevice::Create(curRenderTarget); fCanvas = new SkCanvas(fGpuDevice); } fDebugger->setWindowSize(w, h); draw(); }
void GSDeviceOGL::CreateTextureFX() { GL_PUSH("CreateTextureFX"); m_vs_cb = new GSUniformBufferOGL(g_vs_cb_index, sizeof(VSConstantBuffer)); m_ps_cb = new GSUniformBufferOGL(g_ps_cb_index, sizeof(PSConstantBuffer)); // warning 1 sampler by image unit. So you cannot reuse m_ps_ss... m_palette_ss = CreateSampler(false, false, false); gl_BindSampler(1, m_palette_ss); // Pre compile all Geometry & Vertex Shader // It might cost a seconds at startup but it would reduce benchmark pollution for (uint32 key = 0; key < countof(m_gs); key++) { GSSelector sel(key); if (sel.point == sel.sprite) m_gs[key] = 0; else m_gs[key] = CompileGS(GSSelector(key)); } for (uint32 key = 0; key < countof(m_vs); key++) { // wildhack is only useful if both TME and FST are enabled. VSSelector sel(key); if (sel.wildhack && (!sel.tme || !sel.fst)) m_vs[key] = 0; else m_vs[key] = CompileVS(sel, !GLLoader::found_GL_ARB_clip_control); } // Enable all bits for stencil operations. Technically 1 bit is // enough but buffer is polluted with noise. Clear will be limited // to the mask. glStencilMask(0xFF); for (uint32 key = 0; key < countof(m_om_dss); key++) { m_om_dss[key] = CreateDepthStencil(OMDepthStencilSelector(key)); } // Help to debug FS in apitrace m_apitrace = CompilePS(PSSelector()); GL_POP(); }
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); }
bool SkOSWindow::attachGL(int msaaSampleCount, bool deepColor, AttachmentInfo* info) { HDC dc = GetDC((HWND)fHWND); if (NULL == fHGLRC) { fHGLRC = SkCreateWGLContext(dc, msaaSampleCount, deepColor, kGLPreferCompatibilityProfile_SkWGLContextRequest); if (NULL == fHGLRC) { return false; } glClearStencil(0); glClearColor(0, 0, 0, 0); glStencilMask(0xffffffff); glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT); } if (wglMakeCurrent(dc, (HGLRC)fHGLRC)) { // use DescribePixelFormat to get the stencil and color bit depth. int pixelFormat = GetPixelFormat(dc); PIXELFORMATDESCRIPTOR pfd; DescribePixelFormat(dc, pixelFormat, sizeof(pfd), &pfd); info->fStencilBits = pfd.cStencilBits; // pfd.cColorBits includes alpha, so it will be 32 in 8/8/8/8 and 10/10/10/2 info->fColorBits = pfd.cRedBits + pfd.cGreenBits + pfd.cBlueBits; // Get sample count if the MSAA WGL extension is present SkWGLExtensions extensions; if (extensions.hasExtension(dc, "WGL_ARB_multisample")) { static const int kSampleCountAttr = SK_WGL_SAMPLES; extensions.getPixelFormatAttribiv(dc, pixelFormat, 0, 1, &kSampleCountAttr, &info->fSampleCount); } else { info->fSampleCount = 0; } glViewport(0, 0, SkScalarRoundToInt(this->width()), SkScalarRoundToInt(this->height())); return true; } return false; }
void GLStateCacheManagerImp::initializeCache() { glBlendEquation(GL_FUNC_ADD); if(GLEW_VERSION_2_0) { glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD); } else if(GLEW_EXT_blend_equation_separate) { glBlendEquationSeparateEXT(GL_FUNC_ADD, GL_FUNC_ADD); } glBlendFunc(GL_ONE, GL_ZERO); glCullFace(mCullFace); glDepthFunc(mDepthFunc); glDepthMask(mDepthMask); glStencilMask(mStencilMask); glClearDepth(mClearDepth); glBindTexture(GL_TEXTURE_2D, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindFramebufferEXT(GL_FRAMEBUFFER, 0); glBindRenderbufferEXT(GL_RENDERBUFFER, 0); glActiveTexture(GL_TEXTURE0); glClearColor(mClearColour[0], mClearColour[1], mClearColour[2], mClearColour[3]); glColorMask(mColourMask[0], mColourMask[1], mColourMask[2], mColourMask[3]); glPolygonMode(GL_FRONT_AND_BACK, mPolygonMode); }
void renderFrame() { currentRotation = currentRotation*0.9f + rotation * 0.1f; glStencilMask(0xff); checkGlError("glStencilMask"); glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); checkGlError("glClear"); nvgBeginFrame(vg, w, h, w/h); nvgBeginPath(vg); nvgMoveTo(vg, verticeX(90.f), verticeY(90.f)); nvgLineTo(vg, verticeX(90.f + 120.0f), verticeY(90.0f + 120.0f)); nvgLineTo(vg, verticeX(90.f + 240.f), verticeY(90.0f + 240.0f) ); nvgClosePath(vg); nvgFillColor(vg, nvgRGBA(255,192,0,255)); nvgFill(vg); nvgFillColor(vg, nvgRGBA(255,192,0,255)); nvgEndFrame(vg); }
bool SetupOutline(const AbstractAirspace &airspace) { AirspaceClass type = airspace.GetType(); if (settings.black_outline) canvas.SelectBlackPen(); else if (settings.classes[type].border_width == 0) // Don't draw outlines if border_width == 0 return false; else canvas.Select(look.classes[type].border_pen); canvas.SelectHollowBrush(); // set bit 1 in stencil buffer, where an outline is drawn glStencilFunc(GL_ALWAYS, 3, 3); glStencilMask(2); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); return true; }
void SkGLWidget::createRenderTarget() { if (!fCurContext) { return; } glDisable(GL_SCISSOR_TEST); glStencilMask(0xffffffff); glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); fCurContext->resetContext(); fGpuDevice.reset(NULL); fCanvas.reset(NULL); GrBackendRenderTargetDesc desc = this->getDesc(this->width(), this->height()); desc.fOrigin = kBottomLeft_GrSurfaceOrigin; SkAutoTUnref<GrRenderTarget> curRenderTarget(fCurContext->wrapBackendRenderTarget(desc)); SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType); fGpuDevice.reset(SkGpuDevice::Create(curRenderTarget, &props)); fCanvas.reset(new SkCanvas(fGpuDevice)); }
void RawStencilBufferTest6::setupStencilForClippingOnPlane(GLint plane) { GLint planeMask = 0x1 << plane; glStencilMask(planeMask); glStencilFunc(GL_NEVER, 0, planeMask); glStencilOp(GL_REPLACE, GL_KEEP, GL_KEEP); DrawPrimitives::drawSolidRect(Vec2::ZERO, Vec2(Director::getInstance()->getWinSize()), Color4F(1, 1, 1, 1)); glStencilFunc(GL_NEVER, planeMask, planeMask); glStencilOp(GL_REPLACE, GL_KEEP, GL_KEEP); glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); #if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32) || (CC_TARGET_PLATFORM == CC_PLATFORM_LINUX) || (CC_TARGET_PLATFORM == CC_PLATFORM_MAC) glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, _alphaThreshold); #else auto program = GLProgramCache::getInstance()->getGLProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_ALPHA_TEST_NO_MV); GLint alphaValueLocation = glGetUniformLocation(program->getProgram(), GLProgram::UNIFORM_NAME_ALPHA_TEST_VALUE); program->use(); program->setUniformLocationWith1f(alphaValueLocation, _alphaThreshold); #endif glFlush(); }
void RawStencilBufferTest6::setupStencilForClippingOnPlane(GLint plane) { GLint planeMask = 0x1 << plane; glStencilMask(planeMask); glStencilFunc(GL_NEVER, 0, planeMask); glStencilOp(GL_REPLACE, GL_KEEP, GL_KEEP); ccDrawSolidRect(CCPointZero, ccpFromSize(CCDirector::sharedDirector()->getWinSize()), ccc4f(1, 1, 1, 1)); glStencilFunc(GL_NEVER, planeMask, planeMask); glStencilOp(GL_REPLACE, GL_KEEP, GL_KEEP); glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); #if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32) || (CC_TARGET_PLATFORM == CC_PLATFORM_LINUX) || (CC_TARGET_PLATFORM == CC_PLATFORM_MAC) glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, _alphaThreshold); #else CCGLProgram *program = CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTextureColorAlphaTest); GLint alphaValueLocation = glGetUniformLocation(program->getProgram(), kCCUniformAlphaTestValue); program->setUniformLocationWith1f(alphaValueLocation, _alphaThreshold); m_pSprite->setShaderProgram(program); #endif glFlush(); }
void RenderTexture::beginRendering() { const int width = width_; const int height = height_; glBindFramebuffer(GL_FRAMEBUFFER, renderTexture_gl_frame_buffer_->id()); glViewport(0, 0, width, height); glScissor(0, 0, width, height); glDepthMask(GL_TRUE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); invalidateFrameBuffer(GL_FRAMEBUFFER, true, true, true); if ((back_color_[0] + back_color_[1] + back_color_[2] + use_stencil_) != 0) { int mask = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT; glClearColor(back_color_[0], back_color_[1], back_color_[2], 1); if (use_stencil_) { mask |= GL_STENCIL_BUFFER_BIT; glStencilMask(~0); } glClear(mask); } else { glClear(GL_DEPTH_BUFFER_BIT); } }
void display() { glClearColor(0.5, 0.5, 0.5, 1.0); glClearDepth(1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glBindVertexArray(vao); // Pass info about the rotation/scale of the entire Rubik's cube glUniformMatrix4fv(uRotationMat, 1, 0, rotationMat); glUniform1f(uScale,scale); updateRotationProgress(); // Let the vertex shader handle all the angle calculations glUniform1f(uRotationProgress,rotationProgress); // Draw 27 cubes based on initial cube glClearStencil(0); glStencilMask(0xFF); glEnable(GL_STENCIL_TEST); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); for (int i=0; i<NUM_CUBES; i++) { // Stencil buffer: // http://en.wikibooks.org/wiki/OpenGL_Programming/Object_selection glStencilFunc(GL_ALWAYS, i+1, 0xFF); // i+1 because 0 is used for background glUniform1i(uCubeId,i); glUniform1i(uPositions,positions[i]); glUniform1iv(uColors,FACES_PER_CUBE,colors[i]); glUniform1i(uRotationAxes,rotationAxes[i]); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glDrawElements(GL_TRIANGLES, VERT_PER_CUBE, GL_UNSIGNED_SHORT, 0); } glBindVertexArray(0); glutSwapBuffers(); }
void Engine::GraphicsRenderer::setGeometryState(void) const { glBindFramebuffer(GL_FRAMEBUFFER, 0); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glDepthMask(GL_TRUE); glEnable(GL_STENCIL_TEST); glStencilMask(0xFF); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glStencilFunc(GL_ALWAYS, 1, 0xFF); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); glDisable(GL_CULL_FACE); glViewport(0, 0, _width, _height); glDepthRangef(0.0f, 1.0f); }
void StencilStateManager::onAfterVisit() { /////////////////////////////////// // CLEANUP // manually restore the stencil state glStencilFunc(_currentStencilFunc, _currentStencilRef, _currentStencilValueMask); // RenderState::StateBlock::_defaultState->setStencilFunction((RenderState::StencilFunction)_currentStencilFunc, _currentStencilRef, _currentStencilValueMask); glStencilOp(_currentStencilFail, _currentStencilPassDepthFail, _currentStencilPassDepthPass); // RenderState::StateBlock::_defaultState->setStencilOperation((RenderState::StencilOperation)_currentStencilFail, // (RenderState::StencilOperation)_currentStencilPassDepthFail, // (RenderState::StencilOperation)_currentStencilPassDepthPass); glStencilMask(_currentStencilWriteMask); if (!_currentStencilEnabled) { glDisable(GL_STENCIL_TEST); // RenderState::StateBlock::_defaultState->setStencilTest(false); } // we are done using this layer, decrement s_layer--; }
static void glsm_state_bind(void) { unsigned i; for (i = 0; i < MAX_ATTRIB; i++) { if (gl_state.vertex_attrib_pointer.enabled[i]) glEnableVertexAttribArray(i); else glDisableVertexAttribArray(i); } glBindFramebuffer(RARCH_GL_FRAMEBUFFER, hw_render.get_current_framebuffer()); if (gl_state.blendfunc.used) glBlendFunc( gl_state.blendfunc.sfactor, gl_state.blendfunc.dfactor); if (gl_state.blendfunc_separate.used) glBlendFuncSeparate( gl_state.blendfunc_separate.srcRGB, gl_state.blendfunc_separate.dstRGB, gl_state.blendfunc_separate.srcAlpha, gl_state.blendfunc_separate.dstAlpha ); glClearColor( gl_state.clear_color.r, gl_state.clear_color.g, gl_state.clear_color.b, gl_state.clear_color.a); if (gl_state.depthfunc.used) glDepthFunc(gl_state.depthfunc.func); if (gl_state.colormask.used) glColorMask( gl_state.colormask.red, gl_state.colormask.green, gl_state.colormask.blue, gl_state.colormask.alpha); if (gl_state.cullface.used) glCullFace(gl_state.cullface.mode); if (gl_state.depthmask.used) glDepthMask(gl_state.depthmask.mask); if (gl_state.polygonoffset.used) glPolygonOffset( gl_state.polygonoffset.factor, gl_state.polygonoffset.units); if (gl_state.scissor.used) glScissor( gl_state.scissor.x, gl_state.scissor.y, gl_state.scissor.w, gl_state.scissor.h); glUseProgram(gl_state.program); glViewport( gl_state.viewport.x, gl_state.viewport.y, gl_state.viewport.w, gl_state.viewport.h); #ifdef CORE glBindVertexArray(gl_state.vao); #endif for(i = 0; i < SGL_CAP_MAX; i ++) { if (gl_state.cap_state[i]) glEnable(gl_state.cap_translate[i]); } if (gl_state.frontface.used) glFrontFace(gl_state.frontface.mode); if (gl_state.stencilmask.used) glStencilMask(gl_state.stencilmask.mask); if (gl_state.stencilop.used) glStencilOp(gl_state.stencilop.sfail, gl_state.stencilop.dpfail, gl_state.stencilop.dppass); if (gl_state.stencilfunc.used) glStencilFunc( gl_state.stencilfunc.func, gl_state.stencilfunc.ref, gl_state.stencilfunc.mask); for (i = 0; i < MAX_TEXTURE; i ++) { glActiveTexture(GL_TEXTURE0 + i); glBindTexture(GL_TEXTURE_2D, gl_state.bind_textures.ids[i]); } glActiveTexture(GL_TEXTURE0 + gl_state.active_texture); glBindBuffer(GL_ARRAY_BUFFER, 0); }
void rglStencilMask(GLenum mask) { glStencilMask(mask); gl_state.stencilmask.used = true; gl_state.stencilmask.mask = mask; }
QSGRenderer::ClipType QSGRenderer::updateStencilClip(const QSGClipNode *clip) { if (!clip) { glDisable(GL_STENCIL_TEST); glDisable(GL_SCISSOR_TEST); return NoClip; } bool stencilEnabled = false; bool scissorEnabled = false; glDisable(GL_SCISSOR_TEST); int clipDepth = 0; QRect clipRect; while (clip) { QMatrix4x4 m = m_current_projection_matrix; if (clip->matrix()) m *= *clip->matrix(); // TODO: Check for multisampling and pixel grid alignment. bool canUseScissor = clip->isRectangular() && qFuzzyIsNull(m(0, 1)) && qFuzzyIsNull(m(0, 2)) && qFuzzyIsNull(m(1, 0)) && qFuzzyIsNull(m(1, 2)); if (canUseScissor) { QRectF bbox = clip->clipRect(); qreal invW = 1 / m(3, 3); qreal fx1 = (bbox.left() * m(0, 0) + m(0, 3)) * invW; qreal fy1 = (bbox.bottom() * m(1, 1) + m(1, 3)) * invW; qreal fx2 = (bbox.right() * m(0, 0) + m(0, 3)) * invW; qreal fy2 = (bbox.top() * m(1, 1) + m(1, 3)) * invW; GLint ix1 = qRound((fx1 + 1) * m_device_rect.width() * qreal(0.5)); GLint iy1 = qRound((fy1 + 1) * m_device_rect.height() * qreal(0.5)); GLint ix2 = qRound((fx2 + 1) * m_device_rect.width() * qreal(0.5)); GLint iy2 = qRound((fy2 + 1) * m_device_rect.height() * qreal(0.5)); if (!scissorEnabled) { clipRect = QRect(ix1, iy1, ix2 - ix1, iy2 - iy1); glEnable(GL_SCISSOR_TEST); scissorEnabled = true; } else { clipRect &= QRect(ix1, iy1, ix2 - ix1, iy2 - iy1); } clipRect = clipRect.normalized(); glScissor(clipRect.x(), clipRect.y(), clipRect.width(), clipRect.height()); } else { if (!stencilEnabled) { if (!m_clip_program.isLinked()) { m_clip_program.addShaderFromSourceCode(QGLShader::Vertex, "attribute highp vec4 vCoord; \n" "uniform highp mat4 matrix; \n" "void main() { \n" " gl_Position = matrix * vCoord; \n" "}"); m_clip_program.addShaderFromSourceCode(QGLShader::Fragment, "void main() { \n" " gl_FragColor = vec4(0.81, 0.83, 0.12, 1.0); \n" // Trolltech green ftw! "}"); m_clip_program.bindAttributeLocation("vCoord", 0); m_clip_program.link(); m_clip_matrix_id = m_clip_program.uniformLocation("matrix"); } glStencilMask(0xff); // write mask glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); glEnable(GL_STENCIL_TEST); glDisable(GL_DEPTH_TEST); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDepthMask(GL_FALSE); m_clip_program.bind(); m_clip_program.enableAttributeArray(0); stencilEnabled = true; } glStencilFunc(GL_EQUAL, clipDepth, 0xff); // stencil test, ref, test mask glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); // stencil fail, z fail, z pass const QSGGeometry *geometry = clip->geometry(); Q_ASSERT(geometry->attributeCount() > 0); const QSGGeometry::Attribute *a = geometry->attributes(); glVertexAttribPointer(0, a->tupleSize, a->type, GL_FALSE, geometry->stride(), geometry->vertexData()); m_clip_program.setUniformValue(m_clip_matrix_id, m); draw(clip); ++clipDepth; } clip = clip->clipList(); } if (stencilEnabled) { m_clip_program.disableAttributeArray(0); glEnable(GL_DEPTH_TEST); glStencilFunc(GL_EQUAL, clipDepth, 0xff); // stencil test, ref, test mask glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); // stencil fail, z fail, z pass glStencilMask(0); // write mask bindable()->reactivate(); //glDepthMask(GL_TRUE); // must be reset correctly by caller. } else { glDisable(GL_STENCIL_TEST); } if (!scissorEnabled) glDisable(GL_SCISSOR_TEST); return stencilEnabled ? StencilClip : ScissorClip; }
void opengl_state::init() { int i; glDisable(GL_BLEND); blend_Status = GL_FALSE; glDisable(GL_DEPTH_TEST); depthtest_Status = GL_FALSE; glDisable(GL_SCISSOR_TEST); scissortest_Status = GL_FALSE; glDisable(GL_CULL_FACE); cullface_Status = GL_FALSE; glDisable(GL_POLYGON_OFFSET_FILL); polygonoffsetfill_Status = GL_FALSE; polygon_offset_Factor = 0.0f; polygon_offset_Unit = 0.0f; normalize_Status = GL_FALSE; for (i = 0; i < (int)(sizeof(clipplane_Status) / sizeof(GLboolean)); i++) { //glDisable(GL_CLIP_PLANE0+i); clipplane_Status[i] = GL_FALSE; } for (i = 0; i < (int)(sizeof(clipdistance_Status) / sizeof(GLboolean)); i++) { //glDisable(GL_CLIP_DISTANCE0+i); clipdistance_Status[i] = GL_FALSE; } glDepthMask(GL_FALSE); depthmask_Status = GL_FALSE; glFrontFace(GL_CCW); frontface_Value = GL_CCW; glCullFace(GL_BACK); cullface_Value = GL_BACK; glBlendFunc(GL_ONE, GL_ZERO); blendfunc_Value.first = GL_ONE; blendfunc_Value.first = GL_ZERO; buffer_blendfunc_Value.fill(blendfunc_Value); glDepthFunc(GL_LESS); depthfunc_Value = GL_LESS; glGetFloatv(GL_LINE_WIDTH, &line_width_Value); current_program = 0; glUseProgram(0); current_framebuffer = 0; glBindFramebuffer(GL_FRAMEBUFFER, 0); framebuffer_stack.clear(); stencilFunc = GL_ALWAYS; stencilFuncRef = 0; stencilFuncMask = 0xFFFFFFFF; glStencilFunc(stencilFunc, stencilFuncRef, stencilFuncMask); stencilMask = 0xFFFFFFFF; glStencilMask(stencilMask); stencilOpFrontStencilFail = GL_KEEP; stencilOpFrontDepthFail = GL_KEEP; stencilOpFrontPass = GL_KEEP; stencilOpBackStencilFail = GL_KEEP; stencilOpBackDepthFail = GL_KEEP; stencilOpBackPass = GL_KEEP; glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); colormask_Status.x = true; colormask_Status.y = true; colormask_Status.z = true; colormask_Status.w = true; glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); }