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);
}