void ScreenAreaGl::on_realize() { Gtk::DrawingArea::on_realize(); Glib::RefPtr<Gdk::GL::Window> glwindow = get_gl_window(); if (!glwindow->gl_begin(get_gl_context())) return; glDisable(GL_CULL_FACE); glEnable(GL_TEXTURE_2D); if (glIsTexture(m_uiScreenTexture)) glDeleteTextures(1, &m_uiScreenTexture); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 1.0, 0.0, 0.0, 1.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glGenTextures(1, &m_uiScreenTexture); glBindTexture(GL_TEXTURE_2D, m_uiScreenTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); vUpdateTexture(); glClearColor(0.0, 0.0, 0.0, 1.0); glClear(GL_COLOR_BUFFER_BIT); glwindow->gl_end(); }
void Viewer::on_realize() { // Do some OpenGL setup. // First, let the base class do whatever it needs to Gtk::GL::DrawingArea::on_realize(); Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable(); if (!gldrawable) return; if (!gldrawable->gl_begin(get_gl_context())) return; glShadeModel(GL_SMOOTH); glClearColor( 0.4, 0.4, 0.4, 0.0 ); sphere = glGenLists(1); glNewList(sphere, GL_COMPILE); q = gluNewQuadric(); // Create A New Quadratic gluQuadricNormals(q, GL_SMOOTH); // Generate Smooth Normals For The Quad gluQuadricTexture(q, GL_TRUE); // Enable Texture Coords For The Quad gluSphere(q, 1.0f, 32, 32); glEndList(); root->set_id(sphere); gldrawable->gl_end(); }
bool RHDrawingArea::on_expose_event(GdkEventExpose* event) { Glib::RefPtr<Gdk::GL::Window> gl_window = get_gl_window(); if (!gl_window->gl_begin(get_gl_context())) { return false; } glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glCallList(1); if (gl_window->is_double_buffered()) { gl_window->swap_buffers(); } else { glFlush(); } gl_window->gl_end(); return true; }
bool Viewer::on_expose_event(GdkEventExpose* event) { Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable(); if (!gldrawable) return false; if (!gldrawable->gl_begin(get_gl_context())) return false; draw_init(get_width(), get_height()); // Transforms each point by matrix m_perspective * m_view * m_model. std::vector<LineSegment4D> lineSegments = rootNode->getTransformedLineSegments(); renderHomogenousLines(lineSegments); // Draw viewport box. const Colour BLACK(0); set_colour(BLACK); const Point2D viewportBL = Point2D(viewportTL[0], viewportBR[1]); const Point2D viewportTR = Point2D(viewportBR[0], viewportTL[1]); draw_line(viewportTL, viewportBL); draw_line(viewportBL, viewportBR); draw_line(viewportBR, viewportTR); draw_line(viewportTR, viewportTL); draw_complete(); // Swap the contents of the front and back buffers so we see what we // just drew. This should only be done if double buffering is enabled. gldrawable->swap_buffers(); gldrawable->gl_end(); return true; }
void ViewGL::init() { _window = get_window(); _glcontext = get_gl_context(); _glwindow = get_gl_window(); if (not _glwindow->gl_begin(_glcontext)) { UTILS_ERROR("OpenGL begin failed"); } else { UTILS_INFO("OpenGL begin ok"); glEnable(GL_DEPTH_TEST); glShadeModel(GL_SMOOTH); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); setGlColor(GL_SPECULAR, {{0.8f, 0.8f, 0.8f, 1.f}}); setGlColor(GL_SHININESS, {{10.f, 10.f, 10.f, 1.f}}); _glwindow->gl_end(); } }
void ScreenAreaGl::vOnWidgetResize() { Glib::RefPtr<Gdk::GL::Window> glwindow = get_gl_window(); int iWidth = get_width(); int iHeight = get_height(); float fScreenAspect = (float) m_iScaledWidth / m_iScaledHeight, fWindowAspect = (float) iWidth / iHeight; if (!glwindow->gl_begin(get_gl_context())) return; if (fWindowAspect == fScreenAspect) glViewport(0, 0, iWidth, iHeight); else if (fWindowAspect < fScreenAspect) { int iAspectHeight = (int)(iWidth / fScreenAspect); glViewport(0, (iHeight - iAspectHeight) / 2, iWidth, iAspectHeight); } else { int iAspectWidth = (int)(iHeight * fScreenAspect); glViewport((iWidth - iAspectWidth) / 2, 0, iAspectWidth, iHeight); } glwindow->gl_end(); }
bool ScreenAreaGl::on_expose_event(GdkEventExpose * _pstEvent) { if (!m_bEnableRender) return true; Glib::RefPtr<Gdk::GL::Window> glwindow = get_gl_window(); if (!glwindow->gl_begin(get_gl_context())) return false; glClear( GL_COLOR_BUFFER_BIT ); glPixelStorei(GL_UNPACK_ROW_LENGTH, m_iScaledWidth + 1); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_iScaledWidth + 1, m_iScaledHeight, GL_RGBA, GL_UNSIGNED_BYTE, m_puiPixels); glBegin(GL_TRIANGLE_STRIP); glTexCoord2f(0.0f, 0.0f); glVertex3i(0, 0, 0); glTexCoord2f(m_iScaledWidth / (GLfloat) m_iTextureSize, 0.0f); glVertex3i(1, 0, 0); glTexCoord2f(0.0f, m_iScaledHeight / (GLfloat) m_iTextureSize); glVertex3i(0, 1, 0); glTexCoord2f(m_iScaledWidth / (GLfloat) m_iTextureSize, m_iScaledHeight / (GLfloat) m_iTextureSize); glVertex3i(1, 1, 0); glEnd(); glwindow->swap_buffers(); glwindow->gl_end(); return true; }
void GLCpuPosInstancedArraysBench::onDraw(const int loops, SkCanvas* canvas) { const GrGLContext* ctx = get_gl_context(canvas); if (!ctx) { return; } const GrGLInterface* gl = ctx->interface(); uint32_t maxTrianglesPerFlush = fDrawDiv == 0 ? kNumTri : kDrawMultiplier / fDrawDiv; uint32_t trianglesToDraw = loops * kDrawMultiplier; if (kUseInstance_VboSetup == fVboSetup) { while (trianglesToDraw > 0) { uint32_t triangles = SkTMin(trianglesToDraw, maxTrianglesPerFlush); GR_GL_CALL(gl, DrawArraysInstanced(GR_GL_TRIANGLES, 0, kVerticesPerTri, triangles)); trianglesToDraw -= triangles; } } else { while (trianglesToDraw > 0) { uint32_t triangles = SkTMin(trianglesToDraw, maxTrianglesPerFlush); GR_GL_CALL(gl, DrawArrays(GR_GL_TRIANGLES, 0, kVerticesPerTri * triangles)); trianglesToDraw -= triangles; } } #ifdef DUMP_IMAGES //const char* filename = "/data/local/tmp/out.png"; SkString filename("out"); filename.appendf("_%s.png", this->getName()); dump_image(gl, kScreenWidth, kScreenHeight, filename.c_str()); #endif }
bool Viewer::on_configure_event(GdkEventConfigure* event) { Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable(); if (!gldrawable) return false; if (!gldrawable->gl_begin(get_gl_context())) return false; // Set up perspective projection, using current size and aspect // ratio of display glMatrixMode(GL_PROJECTION); glLoadIdentity(); glViewport(0, 0, event->width, event->height); gluPerspective(40.0, (GLfloat)event->width/(GLfloat)event->height, 0.1, 1000.0); // Reset to modelview matrix mode glMatrixMode(GL_MODELVIEW); gldrawable->gl_end(); return true; }
void GLInstancedArraysBench::onPerCanvasPreDraw(SkCanvas* canvas) { // This bench exclusively tests GL calls directly const GrGLContext* ctx = get_gl_context(canvas); if (!ctx) { return; } this->setup(ctx); }
bool ImageDrawingArea::BeginGL() { if ( !get_gl_window()->gl_begin( get_gl_context() ) ) { return false; } return true; }
void render_surface::on_realize() { python::gil_lock L; Gtk::GL::DrawingArea::on_realize(); if (!share_list) { share_list = get_gl_context(); } assert( share_list); }
void ScreenAreaGl::vOnSizeUpdated() { if (!is_realized()) return; Glib::RefPtr<Gdk::GL::Window> glwindow = get_gl_window(); if (!glwindow->gl_begin(get_gl_context())) return; vUpdateTexture(); glwindow->gl_end(); }
bool RHDrawingArea::on_configure_event(GdkEventConfigure* event) { Glib::RefPtr<Gdk::GL::Window> gl_window = get_gl_window(); if (!gl_window->gl_begin(get_gl_context())) { return false; } glViewport(0, 0, get_width(), get_height()); gl_window->gl_end(); return true; }
void GLInstancedArraysBench::onPerCanvasPostDraw(SkCanvas* canvas) { // This bench exclusively tests GL calls directly const GrGLContext* ctx = get_gl_context(canvas); if (!ctx) { return; } const GrGLInterface* gl = ctx->interface(); // teardown GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, 0)); GR_GL_CALL(gl, BindVertexArray(0)); GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0)); GR_GL_CALL(gl, BindFramebuffer(GR_GL_FRAMEBUFFER, 0)); GR_GL_CALL(gl, DeleteTextures(1, &fTexture)); this->teardown(gl); }
bool Viewer::on_configure_event( GdkEventConfigure* /*event*/ ) { Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable(); if ( !gldrawable ) { return false; } if ( !gldrawable->gl_begin(get_gl_context()) ) { return false; } gldrawable->gl_end(); return true; }
void Viewer::on_realize() { // Do some OpenGL setup. // First, let the base class do whatever it needs to Gtk::GL::DrawingArea::on_realize(); Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable(); if (!gldrawable) return; if (!gldrawable->gl_begin(get_gl_context())) return; gldrawable->gl_end(); reset_view(); // Redraw label first time. reset_window_label(); }
void RHDrawingArea::on_realize() { Gtk::DrawingArea::on_realize(); Glib::RefPtr<Gdk::GL::Window> gl_window = get_gl_window(); if (!gl_window->gl_begin(get_gl_context())) { return; } GLUquadricObj* qobj = gluNewQuadric(); gluQuadricDrawStyle(qobj, GLU_FILL); glNewList(1, GL_COMPILE); gluSphere(qobj, 1.0, 20, 20); glEndList(); static GLfloat light_diffuse[] = {1.0, 0.0, 0.0, 1.0}; static GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0}; glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); glClearColor(1.0, 1.0, 1.0, 1.0); glClearDepth(1.0); glViewport(0, 0, get_width(), get_height()); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(40.0, 1.0, 1.0, 10.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(0.0, 0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); glTranslatef(0.0, 0.0, -3.0); gl_window->gl_end(); }
bool Viewer::on_configure_event(GdkEventConfigure* event) { Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable(); if (!gldrawable) return false; if (!gldrawable->gl_begin(get_gl_context())) return false; gldrawable->gl_end(); if (firstConfig) { firstConfig = false; reset_view(); } else { reset_perspective_screen(); } return true; }
void Viewer::on_realize() { // Do some OpenGL setup. // First, let the base class do whatever it needs to Gtk::GL::DrawingArea::on_realize(); Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable(); if ( !gldrawable ) { return; } if ( !gldrawable->gl_begin(get_gl_context()) ) { return; } gldrawable->gl_end(); }
void Viewer::on_realize() { // Do some OpenGL setup. // First, let the base class do whatever it needs to Gtk::GL::DrawingArea::on_realize(); Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable(); if (!gldrawable) return; if (!gldrawable->gl_begin(get_gl_context())) return; glShadeModel(GL_SMOOTH); glClearColor( 0.4, 0.4, 0.4, 0.0 ); glEnable(GL_DEPTH_TEST); gldrawable->gl_end(); }
bool Viewer::on_expose_event(GdkEventExpose* event) { Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable(); if (!gldrawable) return false; if (!gldrawable->gl_begin(get_gl_context())) return false; if (zBufferCull) { glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); } if (backFaceCull) { glEnable(GL_CULL_FACE); glCullFace(GL_BACK); } if (frontFaceCull) { glEnable(GL_CULL_FACE); glCullFace(GL_FRONT); } // Set up for perspective drawing glMatrixMode(GL_PROJECTION); glLoadIdentity(); glViewport(0, 0, get_width(), get_height()); gluPerspective(40.0, (GLfloat)get_width()/(GLfloat)get_height(), 0.1, 1000.0); // change to model view for drawing glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // Clear framebuffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_NORMALIZE); // Set up lighting // Initialize lighting settings glShadeModel(GL_SMOOTH); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnable(GL_LIGHTING); // Create one light source glEnable(GL_LIGHT0); glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); // Define properties of light float ambientLight0[] = { 0.3f, 0.3f, 0.3f, 1.0f }; float diffuseLight0[] = { 0.8f, 0.8f, 0.8f, 1.0f }; //float specularLight0[] = { 0.6f, 0.6f, 0.6f, 1.0f }; float position0[] = { 0.0f, 0.0f, 0.0f, 1.0f }; glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight0); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight0); //glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight0); glLightfv(GL_LIGHT0, GL_POSITION, position0); // Draw stuff draw_puppet(); if(drawTrackballCircle) draw_trackball_circle(); // Swap the contents of the front and back buffers so we see what we // just drew. This should only be done if double buffering is enabled. gldrawable->swap_buffers(); gldrawable->gl_end(); return true; }
bool Viewer::on_expose_event( GdkEventExpose* /*event*/ ) { Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable(); if ( !gldrawable ) { return false; } if ( !gldrawable->gl_begin(get_gl_context()) ) { return false; } // Start drawing draw_init( get_width(), get_height() ); // Transform the world gnomon for( int i = 0; i < 4; i += 1 ) { m_gnomonTrans[i] = m_viewing * m_gnomon[i]; } // Draw the world gnomon set_colour( Colour(0.1, 0.1, 1.0) ); draw_line2D( m_gnomonTrans[0], m_gnomonTrans[1] ); draw_line2D( m_gnomonTrans[0], m_gnomonTrans[2] ); draw_line2D( m_gnomonTrans[0], m_gnomonTrans[3] ); // Draw the modelling gnomon set_colour( Colour(0.1, 1.0, 0.1) ); draw_modellingGnomon(); // Draw the unit cube set_colour( Colour(0.1, 0.1, 0.1) ); draw_unitCube(); // Initialize the viewport if ( !m_viewflag ) { m_viewport[0] = ( Point2D(get_width() * 0.05, get_height() * 0.05) ); m_viewport[1] = ( Point2D(get_width() * 0.95, get_height() * 0.05) ); m_viewport[2] = ( Point2D(get_width() * 0.95, get_height() * 0.95) ); m_viewport[3] = ( Point2D(get_width() * 0.05, get_height() * 0.95) ); m_viewflag = true; } // Draw the viewport set_colour( Colour(0.1, 0.1, 0.1) ); draw_line( m_viewport[0], m_viewport[1] ); draw_line( m_viewport[1], m_viewport[2] ); draw_line( m_viewport[2], m_viewport[3] ); draw_line( m_viewport[3], m_viewport[0] ); // Finish drawing draw_complete(); // Update the information bar update_infobar(); // Swap the contents of the front and back buffers so we see what we // just drew. This should only be done if double buffering is enabled. gldrawable->swap_buffers(); gldrawable->gl_end(); return true; }
bool Viewer::on_expose_event(GdkEventExpose* event) { Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable(); if (!gldrawable) return false; if (!gldrawable->gl_begin(get_gl_context())) return false; //glEnable(GL_CULL_FACE); //glCullFace(GL_FRONT); // blending glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Set up for perspective drawing glMatrixMode(GL_PROJECTION); glLoadIdentity(); glViewport(0, 0, get_width(), get_height()); gluPerspective(40.0, (GLfloat)get_width()/(GLfloat)get_height(), 0.1, 1000.0); // change to model view for drawing glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // Clear framebuffer{ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Set up lighting glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); // put light behind camera GLfloat lightpos[] = {0.5f, 1.f, 10.f, 0.f}; glLightfv(GL_LIGHT0, GL_POSITION, lightpos); GLfloat ambient[] = {0.2f, 0.2f, 0.2f, 1.f}; GLfloat diffuse[] = {0.8f, 0.8, 0.8f, 1.f}; GLfloat specular[] = {1.f, 1.f, 1.f, 1.f}; glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, specular); glEnable(GL_NORMALIZE); // toogle options DEBUG_MSG("Front/Back Cull " << m_frontCull << "/" << m_backCull << " Zbuf " << m_zBuffer); if (m_frontCull || m_backCull) { glEnable(GL_CULL_FACE); if (m_backCull && m_frontCull) { glCullFace(GL_FRONT_AND_BACK); } else if (m_frontCull) { glCullFace(GL_FRONT); } else { glCullFace(GL_BACK); } } else { glDisable(GL_CULL_FACE); } if (m_zBuffer) { glEnable(GL_DEPTH_TEST); glDepthMask(true); } else { glDisable(GL_DEPTH_TEST); glDepthMask(false); } glPushMatrix(); //Matrix4x4 daT = translation(Vector3D(5.0, 0.0, 0.0)); //glMultMatrixd(daT.transpose().begin()); // gl use column order matrix, m4x4 is row order Matrix4x4 trackballM = m_trackballTranslation * m_trackballRotation; glMultMatrixd(trackballM.transpose().begin()); // draw model m_root->walk_gl(false); // glPushMatrix(); // // push keep into screen // //glTranslated(0.0, 0.0, -10.0); // //glTranslated(0.0, 0.0, -20.0); // GLUquadricObj * quadric = gluNewQuadric(); // gluSphere(quadric, 1.f, 10, 10); // glPopMatrix(); glPopMatrix(); if (m_drawCircle) { draw_trackball_circle(); } // Swap the contents of the front and back buffers so we see what we // just drew. This should only be done if double buffering is enabled. gldrawable->swap_buffers(); gldrawable->gl_end(); return true; }
void render_surface::gl_begin() { bool ok = get_gl_window()->gl_begin(get_gl_context()); assert(ok); }