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