void OGL_Skybox::Render() { OGL_Shader* shader = m_Box->GetShader(); GLboolean CullWasEnabled = glIsEnabled(GL_CULL_FACE); GLint FrontFace; glGetIntegerv(GL_FRONT_FACE, &FrontFace); GLboolean DepthMask; glGetBooleanv(GL_DEPTH_WRITEMASK, &DepthMask); glDisable(GL_CULL_FACE); glFrontFace(GL_CW); glDepthMask(GL_FALSE); shader->EnableShader(); glActiveTexture(GL_TEXTURE0); glUniform1i(shader->GetUniform("skybox"), 0); glBindTexture(GL_TEXTURE_CUBE_MAP, m_Cubemap); glBindVertexArray(m_Box->m_BufferObjects[OGL_Mesh::VAO]); glDrawElements(GL_TRIANGLES, m_Box->m_IndicesCount(), GL_UNSIGNED_INT, nullptr); glBindVertexArray(0); glBindTexture(GL_TEXTURE_CUBE_MAP, 0); if (CullWasEnabled) glEnable(GL_CULL_FACE); if (DepthMask) glDepthMask(GL_TRUE); glFrontFace(FrontFace); }
// Verify that GL_BIND_GENERATES_RESOURCE_CHROMIUM can be queried but not changed TEST_P(BindGeneratesResourceTest, QueryValidation) { GLint intValue = 2; glGetIntegerv(GL_BIND_GENERATES_RESOURCE_CHROMIUM, &intValue); EXPECT_GL_NO_ERROR(); EXPECT_GL_FALSE(intValue); float floatValue = 2.0f; glGetFloatv(GL_BIND_GENERATES_RESOURCE_CHROMIUM, &floatValue); EXPECT_GL_NO_ERROR(); EXPECT_EQ(floatValue, 0.0f); GLboolean boolValue = GL_TRUE; glGetBooleanv(GL_BIND_GENERATES_RESOURCE_CHROMIUM, &boolValue); EXPECT_GL_NO_ERROR(); EXPECT_GL_FALSE(boolValue); boolValue = glIsEnabled(GL_BIND_GENERATES_RESOURCE_CHROMIUM); EXPECT_GL_NO_ERROR(); EXPECT_GL_FALSE(boolValue); glEnable(GL_BIND_GENERATES_RESOURCE_CHROMIUM); EXPECT_GL_ERROR(GL_INVALID_ENUM); glDisable(GL_BIND_GENERATES_RESOURCE_CHROMIUM); EXPECT_GL_ERROR(GL_INVALID_ENUM); }
bool wxGLCanvasBase::SetColour(const wxString& colour) { wxColour col = wxTheColourDatabase->Find(colour); if ( !col.Ok() ) return false; GLboolean isRGBA; glGetBooleanv(GL_RGBA_MODE, &isRGBA); if ( isRGBA ) { glColor3f(col.Red() / 256., col.Green() / 256., col.Blue() / 256.); } else // indexed colour { GLint pix = GetColourIndex(col); if ( pix == -1 ) { wxLogError(_("Failed to allocate colour for OpenGL")); return false; } glIndexi(pix); } return true; }
void DisplaySky(GObject *sky, Camera *cam) { ShaderProgram *prev_shader; RenderState *rs; GLboolean prev_cull; float x,y,z; // camera position static trfm3D localT; rs = RenderStateScene(); glGetBooleanv(GL_CULL_FACE, &prev_cull); prev_shader = GetShaderProgramRS(rs); SetShaderProgramRS(rs, FindShaderScene("sky")); glDisable(GL_CULL_FACE); // move skybox to camera origin GetCameraPosition(cam, &x, &y, &z); SetTransTrfm3D(&localT, x, y, z); PushRS(rs, MG_MODELVIEW); MultTrfmRS(rs, MG_MODELVIEW, &localT); DrawGObject(sky); PopRS(rs, MG_MODELVIEW); // restore shader SetShaderProgramRS(rs, prev_shader); if (prev_cull == GL_TRUE) glEnable(GL_CULL_FACE); }
void View::drawPlane() const { float size = camera()->sceneRadius(); const float step = pow(10.0, floor(log10(size)) -1.0); const int nbSubdivisions = ceil(size/step); size = nbSubdivisions*step; GLboolean isLighting; glGetBooleanv(GL_LIGHTING, &isLighting); glDisable(GL_LIGHTING); glBegin(GL_LINES); for (int i = 0;i <= nbSubdivisions; ++i) { const float pos = size*(2.0*i/nbSubdivisions-1.0); glVertex2f(pos, -size); glVertex2f(pos, +size); glVertex2f(-size, pos); glVertex2f( size, pos); } glEnd(); if(isLighting) glEnable(GL_LIGHTING); }
void Scene3D::drawOrigin() const { GLboolean isLighting; GLfloat color[4]; glGetBooleanv(GL_LIGHTING,&isLighting); glGetFloatv(GL_CURRENT_COLOR,color); glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_2D); //glUseProgram(0); glBegin(GL_LINES); glColor3f(1.0, 0, 0); glVertex3i(1, 1, 1); glVertex3i(1, 0, 0); glColor3f(0, 1.0, 0); glVertex3i(1, 1, 1); glVertex3i(0, 1, 0); glColor3f(0, 0, 1.0); glVertex3i(1, 1, 1); glVertex3i(0, 0, 1); glEnd(); glEnable(GL_TEXTURE_2D); glColor4fv(color); if(isLighting) glEnable(GL_LIGHTING); }
void MeshCommand::applyRenderState() { _renderStateCullFaceEnabled = glIsEnabled(GL_CULL_FACE) != GL_FALSE; _renderStateDepthTest = glIsEnabled(GL_DEPTH_TEST) != GL_FALSE; glGetBooleanv(GL_DEPTH_WRITEMASK, &_renderStateDepthWrite); GLint cullface; glGetIntegerv(GL_CULL_FACE_MODE, &cullface); _renderStateCullFace = (GLenum)cullface; if (_cullFaceEnabled != _renderStateCullFaceEnabled) { _cullFaceEnabled ? glEnable(GL_CULL_FACE) : glDisable(GL_CULL_FACE); } if (_cullFace != _renderStateCullFace) { glCullFace(_cullFace); } if (_depthTestEnabled != _renderStateDepthTest) { _depthTestEnabled ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST); } if (_depthWriteEnabled != _renderStateDepthWrite) { glDepthMask(_depthWriteEnabled); } }
void CGLUtil::renderPatternGL(const float fSize_, const unsigned short usRows_, const unsigned short usCols_ ) const { GLboolean bLightIsOn; glGetBooleanv(GL_LIGHTING,&bLightIsOn); if (bLightIsOn){ glDisable(GL_LIGHTING); } const float usStartZ = -usRows_/2*fSize_; const float usEndZ = usRows_/2*fSize_; const float usStartX = -usCols_/2*fSize_; const float usEndX = usCols_/2*fSize_; glLineWidth(.01f); glPushMatrix(); glColor3f ( .4f , .4f , .4f ); glBegin ( GL_LINES ); //render rows for ( unsigned short r = 0; r <= usRows_; r++ ){ glVertex3f ( usStartX, 0, usStartZ+r*fSize_ ); glVertex3f ( usEndX, 0, usStartZ+r*fSize_ ); } //render cols for ( unsigned short c = 0; c <= usCols_; c++ ){ glVertex3f ( usStartX+c*fSize_, 0, usStartZ ); glVertex3f ( usStartX+c*fSize_, 0, usEndZ ); } glEnd(); glPopMatrix(); if (bLightIsOn){ glEnable(GL_LIGHTING); } return; }
//------------------------------------------------------------------------- void FKCW_3D_Root::visit() { //store depthTest state GLboolean isDoDepthTestOld; glGetBooleanv(GL_DEPTH_TEST,&isDoDepthTestOld); //push matrix kmGLMatrixMode(KM_GL_PROJECTION); kmGLPushMatrix(); kmGLMatrixMode(KM_GL_MODELVIEW); kmGLPushMatrix(); { //apply projection matrix getCamera3D()->applyProjection(); //no matter what the modelview is, set it to identity kmGLMatrixMode(KM_GL_MODELVIEW); kmGLLoadIdentity(); //apply view matrix getCamera3D()->locate(); //call FKCW_3D_Node's visit FKCW_3D_Node::visit(); } //pop matrix kmGLMatrixMode(KM_GL_PROJECTION); kmGLPopMatrix(); kmGLMatrixMode(KM_GL_MODELVIEW); kmGLPopMatrix(); //resotre depthTest state CCDirector::sharedDirector()->setDepthTest(static_cast<bool>(isDoDepthTestOld)); //disable array attribute // KCW_3D_IndexVBO3d::disableAttribArrays(); }
void OpenGL::DrawTexturedRect( Gwen::Texture* pTexture, Gwen::Rect rect, float u1, float v1, float u2, float v2 ) { GLuint* tex = ( GLuint* ) pTexture->data; // Missing image, not loaded properly? if ( !tex ) { return DrawMissingImage( rect ); } Translate( rect ); GLuint boundtex; GLboolean texturesOn; glGetBooleanv( GL_TEXTURE_2D, &texturesOn ); glGetIntegerv( GL_TEXTURE_BINDING_2D, ( GLint* ) &boundtex ); if ( !texturesOn || *tex != boundtex ) { Flush(); glBindTexture( GL_TEXTURE_2D, *tex ); glEnable( GL_TEXTURE_2D ); } AddVert( rect.x, rect.y, u1, v1 ); AddVert( rect.x + rect.w, rect.y, u2, v1 ); AddVert( rect.x, rect.y + rect.h, u1, v2 ); AddVert( rect.x + rect.w, rect.y, u2, v1 ); AddVert( rect.x + rect.w, rect.y + rect.h, u2, v2 ); AddVert( rect.x, rect.y + rect.h, u1, v2 ); }
void XipPrimitiveDraw::lines( SoGLRenderAction* action, const SoMFVec3f& coord, const SoMFInt32& index, const SbColor& color, const float alpha, const float lineWidth, const unsigned short linePattern ) { action->getState()->push(); { GLboolean depthTest; glGetBooleanv( GL_DEPTH_TEST, &depthTest ); if( depthTest ) glDisable( GL_DEPTH_TEST ); SoLinePatternElement::set( action->getState(), linePattern ); SoLineWidthElement::set( action->getState(), lineWidth ); m_Material->diffuseColor.setValue( color ); m_Material->transparency.setValue( alpha ); action->traverse( m_Material ); m_Coords->point.copyFrom( coord ); action->traverse( m_Coords ); m_IndexedLineSet->coordIndex.copyFrom( index ); action->traverse( m_IndexedLineSet ); if( depthTest ) glEnable( GL_DEPTH_TEST ); } action->getState()->pop(); }
void XipPrimitiveDraw::quad( SoGLRenderAction* action, const SbVec3f& origin, const SbVec2f& size, const SbColor& color, const float alpha ) { action->getState()->push(); { GLboolean depthTest; glGetBooleanv( GL_DEPTH_TEST, &depthTest ); if( depthTest ) glDisable( GL_DEPTH_TEST ); m_Material->diffuseColor.setValue( color ); m_Material->transparency.setValue( alpha ); action->traverse( m_Material ); m_Coords->point.setNum(4); m_Coords->point.set1Value( 0, origin ); m_Coords->point.set1Value( 1, origin + SbVec3f( size[0], 0, 0 ) ); m_Coords->point.set1Value( 2, origin + SbVec3f( size[0], size[1], 0 ) ); m_Coords->point.set1Value( 3, origin + SbVec3f( 0, size[1], 0 ) ); action->traverse( m_Coords ); m_FaceSet->numVertices.setValue(4); action->traverse( m_FaceSet ); if( depthTest ) glEnable( GL_DEPTH_TEST ); } action->getState()->pop(); }
bool wxGLCanvasBase::SetColour(const wxString& colour) { wxColour col = wxTheColourDatabase->Find(colour); if ( !col.IsOk() ) return false; #ifdef wxHAS_OPENGL_ES wxGLAPI::glColor3f((GLfloat) (col.Red() / 256.), (GLfloat) (col.Green() / 256.), (GLfloat) (col.Blue() / 256.)); #else GLboolean isRGBA; glGetBooleanv(GL_RGBA_MODE, &isRGBA); if ( isRGBA ) { glColor3f((GLfloat) (col.Red() / 256.), (GLfloat) (col.Green() / 256.), (GLfloat) (col.Blue() / 256.)); } else // indexed colour { GLint pix = GetColourIndex(col); if ( pix == -1 ) { wxLogError(_("Failed to allocate colour for OpenGL")); return false; } glIndexi(pix); } #endif return true; }
void XipPrimitiveDraw::triangle( SoGLRenderAction* action, const SbVec3f& p1, const SbVec3f& p2, const SbVec3f& p3, const SbColor& color, const float alpha ) { action->getState()->push(); { GLboolean depthTest; glGetBooleanv( GL_DEPTH_TEST, &depthTest ); if( depthTest ) glDisable( GL_DEPTH_TEST ); m_Material->diffuseColor.setValue( color ); m_Material->transparency.setValue( alpha ); action->traverse( m_Material ); m_Coords->point.setNum(3); m_Coords->point.set1Value( 0, p1 ); m_Coords->point.set1Value( 1, p2 ); m_Coords->point.set1Value( 2, p3 ); action->traverse( m_Coords ); m_FaceSet->numVertices.setValue(3); action->traverse( m_FaceSet ); if( depthTest ) glEnable( GL_DEPTH_TEST ); } action->getState()->pop(); }
GLboolean GLFont::justify(double width, double height, double adjx, double adjy, const RenderContext& rc) { GLdouble pos[4], pos2[4]; double basex = 0.0, basey = 0.0, scaling = 1.0; GLboolean valid; gl2ps_centering = GL2PS_TEXT_BL; if (adjx > 0) { if (rc.gl2psActive > GL2PS_NONE) scaling = GL2PS_SCALING; if ( adjx > 0.25 && rc.gl2psActive == GL2PS_POSITIONAL) { if (adjx < 0.75) { basex = 0.5; gl2ps_centering = GL2PS_TEXT_B; } else { basex = 1.0; gl2ps_centering = GL2PS_TEXT_BR; } } } if ((adjx != basex) || (adjy != basey)) { glGetDoublev(GL_CURRENT_RASTER_POSITION, pos); pos[0] = pos[0] - scaling*width*(adjx-basex); pos[1] = pos[1] - scaling*height*(adjy-basey); gluUnProject( pos[0], pos[1], pos[2], rc.modelview, rc.projection, rc.viewport, pos2, pos2 + 1, pos2 + 2); glRasterPos3dv(pos2); } glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &valid); return valid; }
void Cc3dSprite::draw(){ assert(m_mesh&&m_texture&&m_indexVBO &&m_program&&m_uniformPassor&&m_lightSource&&m_camera); //store isDoDepthTest GLboolean isDoDepthTestOld; glGetBooleanv(GL_DEPTH_TEST,&isDoDepthTestOld); //set depthTest if(m_isDoDepthTest!=isDoDepthTestOld){ CCDirector::sharedDirector()->setDepthTest(m_isDoDepthTest); } //enable server state (i don't know what this means :( ) ccGLEnable(m_eGLServerState); //pass values for cocos2d-x build-in uniforms m_pShaderProgram->use(); m_pShaderProgram->setUniformsForBuiltins(); //pass values for my own uniforms m_uniformPassor->excuteCallback(this, m_program); //attach texture to texture attach point Cc3dIndexVBO3d::bindTexture(0, m_texture->getName()); //draw m_indexVBO->setPointers(); m_indexVBO->draw(GL_TRIANGLES); Cc3dIndexVBO3d::bindTexture(0, 0); //restore isDoDepthTest CCDirector::sharedDirector()->setDepthTest(isDoDepthTestOld); }
//--------- void Handles::Rotate::draw() const { if (parent == 0 || !this->enabled) return; GLboolean hadLighting; glGetBooleanv(GL_LIGHTING, &hadLighting); if (hadLighting) ofDisableLighting(); ofPushMatrix(); this->doTransform(); ofPushStyle(); shader("fixed").begin(); this->rotateAxis(); this->setStyleFill(); fill.draw(); shader("fixed").end(); ofSetColor(255); if (this->rollover) { ofTranslate(0, GRABSCENE_HANDLES_RADIUS_1 + GRABSCENE_HANDLES_RADIUS_2 * 2); ofSetDrawBitmapMode(OF_BITMAPMODE_MODEL_BILLBOARD); ofDrawBitmapString(this->getReading(), ofPoint()); } ofPopStyle(); ofPopMatrix(); if (hadLighting) ofEnableLighting(); }
void _VerifyGLState(const char* szfile, const char* szfunction, int lineno) { #if defined(HAS_SDL_OPENGL) && defined(_DEBUG) #define printMatrix(matrix) \ { \ for (int ixx = 0 ; ixx<4 ; ixx++) \ { \ CLog::Log(LOGDEBUG, "% 3.3f % 3.3f % 3.3f % 3.3f ", \ matrix[ixx*4], matrix[ixx*4+1], matrix[ixx*4+2], \ matrix[ixx*4+3]); \ } \ } GLenum err = glGetError(); if (err==GL_NO_ERROR) return; CLog::Log(LOGERROR, "GL ERROR: %s\n", gluErrorString(err)); if (szfile && szfunction) CLog::Log(LOGERROR, "In file:%s function:%s line:%d", szfile, szfunction, lineno); GLboolean bools[16]; GLfloat matrix[16]; glGetFloatv(GL_SCISSOR_BOX, matrix); CLog::Log(LOGDEBUG, "Scissor box: %f, %f, %f, %f", matrix[0], matrix[1], matrix[2], matrix[3]); glGetBooleanv(GL_SCISSOR_TEST, bools); CLog::Log(LOGDEBUG, "Scissor test enabled: %d", (int)bools[0]); glGetFloatv(GL_VIEWPORT, matrix); CLog::Log(LOGDEBUG, "Viewport: %f, %f, %f, %f", matrix[0], matrix[1], matrix[2], matrix[3]); glGetFloatv(GL_PROJECTION_MATRIX, matrix); CLog::Log(LOGDEBUG, "Projection Matrix:"); printMatrix(matrix); glGetFloatv(GL_MODELVIEW_MATRIX, matrix); CLog::Log(LOGDEBUG, "Modelview Matrix:"); printMatrix(matrix); // abort(); #endif }
void gsDraw(geosphere * sphere, int f, GAIM_FLOAT normal = 0.0) { int i; e3ga v1; if (sphere->face[f].child[0] >= 0) { for (i = 0; i < 4; i++) gsDraw(sphere, sphere->face[f].child[i], normal); } else { glBegin(GL_TRIANGLES); for (i = 0; i < 3; i++) { glNormal3dv(sphere->vertex[sphere->face[f].v[i]][GRADE1]); glVertex3dv((sphere->vertex[sphere->face[f].v[i]]) [GRADE1]); } glEnd(); if (normal != 0.0) { GLboolean l; glGetBooleanv(GL_LIGHTING, &l); glDisable(GL_LIGHTING); glBegin(GL_LINES); for (i = 0; i < 3; i++) { v1 = sphere->vertex[sphere->face[f].v[i]].normal(); glVertex3dv((sphere->vertex[sphere->face[f].v[i]]) [GRADE1]); glVertex3dv((sphere->vertex[sphere->face[f].v[i]] + v1 * normal)[GRADE1]); } glEnd(); if (l) glEnable(GL_LIGHTING); } } }
void wxGLContext::SetColour(const wxChar *colour) { wxColour the_colour = wxTheColourDatabase->Find(colour); if(the_colour.Ok()) { GLboolean b; glGetBooleanv(GL_RGBA_MODE, &b); if(b) { glColor3ub(the_colour.Red(), the_colour.Green(), the_colour.Blue()); } else { #ifdef __WXMOTIF__ the_colour.AllocColour(m_window->GetXDisplay()); #else the_colour.CalcPixel(wxTheApp->GetMainColormap(wxGetDisplay())); #endif GLint pix = (GLint)the_colour.GetPixel(); if(pix == -1) { wxLogError(wxT("wxGLCanvas: cannot allocate color\n")); return; } glIndexi(pix); } } }
OpenGLSystemInfo::OpenGLSystemInfo(OpenGLWrapper const& wrapper) : m_logManager{ CROISSANT_GET_LOG(OpenGLSystemInfo) }, m_wrapper(wrapper) { m_logManager.Write("Entrée dans OpenGLSystemInfo constructeur"); m_major = m_wrapper.GetInteger(OpenGLValueNameEnum::MajorVersion); m_minor = m_wrapper.GetInteger(OpenGLValueNameEnum::MinorVersion); m_max3DTextureSize = m_wrapper.GetInteger(OpenGLValueNameEnum::Max3DTextureSize); m_maxClipDistance = m_wrapper.GetInteger(OpenGLValueNameEnum::MaxClipDistances); m_maxDrawBuffer = m_wrapper.GetInteger(OpenGLValueNameEnum::MaxDrawBuffers); m_maxIndicesArraySize = m_wrapper.GetInteger(OpenGLValueNameEnum::MaxElementsIndices); m_maxVertexArraySize = m_wrapper.GetInteger(OpenGLValueNameEnum::MaxElementsVertices); m_maxRenderbufferSize = m_wrapper.GetInteger(OpenGLValueNameEnum::MaxRenderbufferSize); m_numExtensions = m_wrapper.GetInteger(OpenGLValueNameEnum::NumExtentions); // TODO : get extension list GLboolean doubleBufferEnabled; glGetBooleanv(GL_DOUBLEBUFFER, &doubleBufferEnabled); if (doubleBufferEnabled == 1) { m_logManager.Write("double buffer supporté."); } else { m_logManager.Write("double buffer non supporté."); } m_logManager.Write("Sortie de OpenGLSystemInfo constructeur"); }
void WypWindow::onSpecial(int key, int x, int y) { switch (key) { /* case GLUT_KEY_DOWN : world.rotateX -= setting.angleInc; break; case GLUT_KEY_UP : world.rotateX += setting.angleInc; break; case GLUT_KEY_LEFT : world.rotateY -= setting.angleInc; break; case GLUT_KEY_RIGHT : world.rotateY += setting.angleInc; break; */ case GLUT_KEY_HOME : dataInit(); break; case GLUT_KEY_F1 : setting.shadingMode = !setting.shadingMode; if (setting.shadingMode) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); else glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); break; case GLUT_KEY_F2 : worldaxis.toggle(); break; case GLUT_KEY_F3 : GLboolean lightingIsOn; glGetBooleanv(GL_LIGHTING, &lightingIsOn); if (lightingIsOn==GL_TRUE) glDisable(GL_LIGHTING); else glEnable(GL_LIGHTING); break; } onSpecialSignal.broadcast(key); }
void GLState::glsGetStateData(const GLenum state_name, const GLType type, void* data) { switch (type) { case GLTYPE_BOOL: glGetBooleanv(state_name, (GLboolean*)data); ERROR_CHECK; break; case GLTYPE_ENUM: case GLTYPE_INT: glGetIntegerv(state_name, (GLint*)data); ERROR_CHECK; break; case GLTYPE_FLOAT: glGetFloatv(state_name, (GLfloat*)data); ERROR_CHECK; break; case GLTYPE_DOUBLE: glGetDoublev(state_name, (GLdouble*)data); ERROR_CHECK; break; case GLTYPE_INT64: glGetInteger64v(state_name, (GLint64*)data); ERROR_CHECK; break; } }
void piglit_init(int argc, char **argv) { glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1.25, 1.25, -1.25, 1.25, -1, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glShadeModel(GL_FLAT); glPixelStorei(GL_PACK_ALIGNMENT, 1); glFrontFace(GL_CW); glCullFace(GL_FRONT); glEnable(GL_CULL_FACE); if (piglit_is_extension_supported("GL_ARB_provoking_vertex")) { provoking_vertex_first = true; } else if (piglit_is_extension_supported("GL_EXT_provoking_vertex")) { provoking_vertex_first = true; } if (provoking_vertex_first) { GLboolean k; glGetBooleanv(GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT, &k); quads_follows_pv_convention = k; } }
void avtOpenGLCurveRenderer::RenderCurves() { // // Make the OpenGL calls to get it into the desired state. // SetupGraphicsLibrary(); // // Set up the OpenGL state // // Turn off lighting if it's on. GLboolean enableLighting; glGetBooleanv(GL_LIGHTING, &enableLighting); if(enableLighting) glDisable(GL_LIGHTING); // Disable depth testing GLboolean enableDepthTest; glGetBooleanv(GL_DEPTH_TEST, &enableDepthTest); if(enableDepthTest) glDisable(GL_DEPTH_TEST); if (atts.GetShowLines()) DrawCurveAsLines(); if (atts.GetShowPoints()) DrawCurveAsSymbols(); if (atts.GetDoLineTimeCue()) { RenderLine(); } if (atts.GetDoBallTimeCue()) { RenderBall(); } // Enable depth testing if it was on. if(enableDepthTest) glEnable(GL_DEPTH_TEST); // Enable lighting again if it was on. if(enableLighting) glEnable(GL_LIGHTING); }
void CglFont::End() { if (!inBeginEnd) { LOG_L(L_ERROR, "called End() without Begin()"); return; } inBeginEnd = false; if (va.drawIndex() == 0) { glPopAttrib(); if (threadSafety) vaMutex.unlock(); return; } GLboolean inListCompile; glGetBooleanv(GL_LIST_INDEX, &inListCompile); if (!inListCompile) { UpdateTexture(); } glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, GetTexture()); // Because texture size can change, texture coordinats are absolute in texels. // We could use also just use GL_TEXTURE_RECTANGLE // but then all shaders would need to detect so and use different funcs & types if supported -> more work glMatrixMode(GL_TEXTURE); glPushMatrix(); glCallList(textureSpaceMatrix); glMatrixMode(GL_MODELVIEW); if (va2.drawIndex() > 0) { if (stripOutlineColors.size() > 1) { ColorMap::iterator sci = stripOutlineColors.begin(); va2.DrawArray2dT(GL_QUADS,TextStripCallback,&sci); } else { glColor4fv(outlineColor); va2.DrawArray2dT(GL_QUADS); } } if (stripTextColors.size() > 1) { ColorMap::iterator sci = stripTextColors.begin(); va.DrawArray2dT(GL_QUADS,TextStripCallback,&sci);//FIXME calls a 0 length strip! } else { if (setColor) glColor4fv(textColor); va.DrawArray2dT(GL_QUADS); } // pop texture matrix glMatrixMode(GL_TEXTURE); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glPopAttrib(); if (threadSafety) vaMutex.unlock(); }
bool GLProgram::initWithByteArrays(const GLchar* vShaderByteArray, const GLchar* fShaderByteArray) { #if (CC_TARGET_PLATFORM == CC_PLATFORM_WP8) GLboolean hasCompiler = false; glGetBooleanv(GL_SHADER_COMPILER, &hasCompiler); _hasShaderCompiler = (hasCompiler == GL_TRUE); if(!_hasShaderCompiler) { return initWithPrecompiledProgramByteArray(vShaderByteArray,fShaderByteArray); } #endif _program = glCreateProgram(); CHECK_GL_ERROR_DEBUG(); _vertShader = _fragShader = 0; if (vShaderByteArray) { if (!compileShader(&_vertShader, GL_VERTEX_SHADER, vShaderByteArray)) { CCLOG("cocos2d: ERROR: Failed to compile vertex shader"); return false; } } // Create and compile fragment shader if (fShaderByteArray) { if (!compileShader(&_fragShader, GL_FRAGMENT_SHADER, fShaderByteArray)) { CCLOG("cocos2d: ERROR: Failed to compile fragment shader"); return false; } } if (_vertShader) { glAttachShader(_program, _vertShader); } CHECK_GL_ERROR_DEBUG(); if (_fragShader) { glAttachShader(_program, _fragShader); } _hashForUniforms.clear(); CHECK_GL_ERROR_DEBUG(); #if (CC_TARGET_PLATFORM == CC_PLATFORM_WP8) || defined(WP8_SHADER_COMPILER) _shaderId = CCPrecompiledShaders::getInstance()->addShaders(vShaderByteArray, fShaderByteArray); #endif return true; }
GLboolean glGetBoolean(GLenum which) { // We allocate an array in case the caller accidentally // invoked on a value that will return more than just // one bool. GLboolean result[32]; glGetBooleanv(which, result); return result[0]; }
void RenderQueue::saveRenderState() { _isDepthEnabled = glIsEnabled(GL_DEPTH_TEST) != GL_FALSE; _isCullEnabled = glIsEnabled(GL_CULL_FACE) != GL_FALSE; glGetBooleanv(GL_DEPTH_WRITEMASK, &_isDepthWrite); CHECK_GL_ERROR_DEBUG(); }
static int GetBoolean(lua_State *L, GLenum pname) { GLboolean data; glGetBooleanv(pname, &data); CheckError(L); lua_pushboolean(L, (data == GL_TRUE)); return 1; }