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