Example #1
0
void exit_display()
{
   int i;

   glXMakeContextCurrent(display, None, None, NULL);
   glXDestroyContext(display, gl_context);
   glXDestroyWindow(display, gl_window);
   glXDestroyPbuffer(display, gl_pbuffer);

#ifdef USE_NV_FENCE
   glDeleteFencesNV(1, &nvFence);
#endif

   XDestroyWindow(display, window);

   for(i = 0; i < numsurfaces; i++) {
     XvMCDestroySurface(display, &surfaces[i]);
   }

   XvMCDestroyBlocks(display, &blocks);
   XvMCDestroyMacroBlocks(display, &macro_blocks);
   XvMCDestroyContext(display, &context);
   XvUngrabPort(display, portNum, CurrentTime);
  
   XCloseDisplay(display);
}
Example #2
0
void Window::configExit( )
{
    if( !_xDisplay ) 
        return;

    leaveNVSwapBarrier();
    configExitFBO();
    exitGLEW();

    glXMakeCurrent( _xDisplay, None, 0 );

    GLXContext context  = getGLXContext();
    XID        drawable = getXDrawable();

    setGLXContext( 0 );
    setXDrawable( 0 );
    XSync( _xDisplay, False ); // WAR assert in glXDestroyContext/xcb_io.c:183

    if( context )
        glXDestroyContext( _xDisplay, context );

    if( drawable )
    {
        if( getIAttribute( eq::Window::IATTR_HINT_DRAWABLE ) == PBUFFER )
            glXDestroyPbuffer( _xDisplay, drawable );
        else
            XDestroyWindow( _xDisplay, drawable );
    }

    EQINFO << "Destroyed GLX context and X drawable " << std::endl;
}
Example #3
0
 ~GlxDrawable() {
     if (pbuffer) {
         glXDestroyPbuffer(display, window);
     } else {
         XDestroyWindow(display, window);
     }
 }
Example #4
0
bool QGLPixelBuffer::hasOpenGLPbuffers()
{
    bool ret = qt_resolve_pbuffer_extensions();

    if (!ret)
	return false;

    int attribs[40];
    int num_configs = 0;

    qt_format_to_attrib_list(QGLFormat::defaultFormat(), attribs);

    GLXFBConfig *configs = glXChooseFBConfig(X11->display, X11->defaultScreen, attribs, &num_configs);
    GLXPbuffer pbuf = 0;
    GLXContext ctx = 0;

    if (configs && num_configs) {
        int pb_attribs[] = {GLX_PBUFFER_WIDTH, 128, GLX_PBUFFER_HEIGHT, 128, XNone};
        pbuf = glXCreatePbuffer(X11->display, configs[0], pb_attribs);
        ctx = glXCreateNewContext(X11->display, configs[0], GLX_RGBA_TYPE, 0, true);
        XFree(configs);
	glXDestroyContext(X11->display, ctx);
	glXDestroyPbuffer(X11->display, pbuf);
    }
    return pbuf && ctx;
}
Example #5
0
GlxContext::~GlxContext()
{
    // Destroy the context
    if (m_context)
    {
#if defined(GLX_DEBUGGING)
        GlxErrorHandler handler(m_display);
#endif

        if (glXGetCurrentContext() == m_context)
            glXMakeCurrent(m_display, None, NULL);
        glXDestroyContext(m_display, m_context);

#if defined(GLX_DEBUGGING)
        if (glxErrorOccurred)
            err() << "GLX error in GlxContext::~GlxContext()" << std::endl;
#endif
    }

    if (m_pbuffer)
    {
        glXDestroyPbuffer(m_display, m_pbuffer);
    }

    // Destroy the window if we own it
    if (m_window && m_ownsWindow)
    {
        xcb_destroy_window(m_connection, m_window);
        xcb_flush(m_connection);
    }

    // Close the connection with the X server
    CloseDisplay(m_display);
}
//----------------------------------------------------------------------------//
void OpenGLGLXPBTextureTarget::initialisePBuffer()
{
    int creation_attrs[] =
    {
        GLX_PBUFFER_WIDTH, d_area.getWidth(),
        GLX_PBUFFER_HEIGHT, d_area.getHeight(),
        GLX_LARGEST_PBUFFER, True,
        GLX_PRESERVED_CONTENTS, True,
        None
    };

    // release any existing pbuffer
    if (d_pbuffer)
        glXDestroyPbuffer(d_dpy, d_pbuffer);

    d_pbuffer = glXCreatePbuffer(d_dpy, d_fbconfig, creation_attrs);

    if (!d_pbuffer)
        throw RendererException("OpenGLGLXPBTextureTarget::initialisePBuffer - "
            "pbuffer creation error:  glXCreatePbuffer() failed");

    // get the real size of the buffer that was created
    GLuint actual_width, actual_height;
    glXQueryDrawable(d_dpy, d_pbuffer, GLX_WIDTH, &actual_width);
    glXQueryDrawable(d_dpy, d_pbuffer, GLX_HEIGHT, &actual_height);
    d_area.setSize(Size(actual_width, actual_height));

    // ensure CEGUI::Texture is wrapping real GL texture and has correct size
    d_CEGUITexture->setOpenGLTexture(d_texture, d_area.getSize());
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GLX13_nglXDestroyPbuffer(JNIEnv *__env, jclass clazz, jlong displayAddress, jlong pbufAddress, jlong __functionAddress) {
	Display *display = (Display *)(intptr_t)displayAddress;
	GLXPbuffer pbuf = (GLXPbuffer)(intptr_t)pbufAddress;
	glXDestroyPbufferPROC glXDestroyPbuffer = (glXDestroyPbufferPROC)(intptr_t)__functionAddress;
	UNUSED_PARAMS(__env, clazz)
	glXDestroyPbuffer(display, pbuf);
}
Example #8
0
	//-------------------------------------------------------------------------------------------------//
	GLXPBuffer::~GLXPBuffer()
	{
		glXDestroyPbuffer(mGLSupport->getGLDisplay(), mContext->mDrawable);
		
		delete mContext;
		
		LogManager::getSingleton().logMessage(LML_NORMAL, "GLXPBuffer::PBuffer destroyed");
	}
void HeadlessView::destroyContext() {
    if (glxPbuffer) {
        glXDestroyPbuffer(xDisplay, glxPbuffer);
        glxPbuffer = 0;
    }

    glXDestroyContext(xDisplay, glContext);
}
Example #10
0
GLOffscreenBuffer::~GLOffscreenBuffer()
{
    if (!m_context)
        return;
    glXMakeCurrent(m_display, None, None);
    glXDestroyContext(m_display, m_context);
    glXDestroyPbuffer(m_display, m_pbuffer);
    XCloseDisplay(m_display);
}
//----------------------------------------------------------------------------//
void OpenGLGLXPBTextureTarget::grabTexture()
{
    if (d_pbuffer)
    {
        glXDestroyPbuffer(d_dpy, d_pbuffer);
        d_pbuffer = 0;
    }

    OpenGLTextureTarget::grabTexture();
}
Example #12
0
void
glx_context_free (GLXState * c)
{
    glXDestroyContext (c->dpy, c->context);
    if (c->pbuffer)
        glXDestroyPbuffer (c->dpy, c->pbuffer);
    if (c->fbconfig)
        XFree (c->fbconfig);
    free (c);
}
Example #13
0
GLXState *
glx_context_new_pbuffer (Display * dpy, int width, int height,
        GLXState * shared)
{
    GLXState * c;
    GLXFBConfig * fbconfig;
    int count;
    GLXContext context;
    GLXPbuffer pbdraw;
    GLXContext sh_context = NULL;

    if (shared)
        sh_context = shared->context;

    int pb_attr[] = {
        GLX_PBUFFER_WIDTH, width,
        GLX_PBUFFER_HEIGHT, height,
        None
    };

    fbconfig = glXChooseFBConfig (dpy, DefaultScreen (dpy),
            attr_list_pb, &count);
    if (fbconfig == NULL || count == 0) {
        fprintf (stderr, "GLX Context Error: No FBConfigs found\n");
        return NULL;
    }

    pbdraw = glXCreatePbuffer (dpy, fbconfig[0], pb_attr);
    if (!pbdraw) {
        fprintf (stderr, "GLX Context Error: Failed to create Pbuffer\n");
        XFree (fbconfig);
        return NULL;
    }

    context = glXCreateNewContext (dpy, fbconfig[0], GLX_RGBA_TYPE,
            sh_context, GL_TRUE);
    if (!context) {
        fprintf (stderr, "GLX Context Error: Failed to get GLX PB context\n");
        glXDestroyPbuffer (dpy, pbdraw);
        XFree (fbconfig);
        return NULL;
    }

    c = malloc (sizeof (GLXState));
    memset (c, 0, sizeof (GLXState));

    c->width = width;
    c->height = height;
    c->dpy = dpy;
    c->fbconfig = fbconfig;
    c->pbuffer = pbdraw;
    c->context = context;

    return c;
}
	GlXOffscreenContext::~GlXOffscreenContext()
	{
		clearActive();

		_ready = false;

		glXDestroyContext(_display, _context);
		glXDestroyPbuffer(_display, _pBuffer);

		XCloseDisplay(_display);
	}
Example #15
0
PBuffer::~PBuffer()
{
    /// Release resources
    mBoundTextures.clear();
    mBoundVertexStream.release();
    /// Finally, destroy the buffer
    Display *dpy = GLEngine::getInstance().getDisplay();
    if(mContext)
        glXDestroyContext(dpy, mContext);
    if(mPBuffer)
        glXDestroyPbuffer(dpy, mPBuffer);
}
Example #16
0
GLOffscreenBuffer::GLOffscreenBuffer(unsigned width, unsigned height)
    : m_width(width)
    , m_height(height)
    , m_display(XOpenDisplay(0))
    , m_pbuffer(0)
    , m_context(0)
{
    if (!m_display) {
        std::cerr << "Error: XOpenDisplay()\n";
        return;
    }

    static const int configAttributes[] = {
        GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
        GLX_RENDER_TYPE, GLX_RGBA_BIT,
        GLX_RED_SIZE, 8,
        GLX_GREEN_SIZE, 8,
        GLX_BLUE_SIZE, 8,
        GLX_ALPHA_SIZE, 8,
        GLX_DOUBLEBUFFER, GL_FALSE,
        0
    };
    int configCount;
    GLXFBConfig* config = glXChooseFBConfig(m_display, 0, configAttributes, &configCount);
    if (!configCount) {
        std::cerr << "Error: glXChooseFBConfig()\n";
        XFree(config);
        XCloseDisplay(m_display);
        return;
    }

    static const int pbufferAttributes[] = {
        GLX_PBUFFER_WIDTH, static_cast<int>(width),
        GLX_PBUFFER_HEIGHT, static_cast<int>(height),
        0
    };
    m_pbuffer = glXCreatePbuffer(m_display, config[0], pbufferAttributes);
    if (!m_pbuffer) {
        std::cerr << "Error: glXCreatePbuffer()\n";
        XFree(config);
        XCloseDisplay(m_display);
        return;
    }

    m_context = glXCreateNewContext(m_display, config[0], GLX_RGBA_TYPE, 0, GL_TRUE);
    XFree(config);
    if (!m_context) {
        std::cerr << "Error: glXCreateNewContext()\n";
        glXDestroyPbuffer(m_display, m_pbuffer);
        XCloseDisplay(m_display);
        return;
    }
}
Example #17
0
void GraphicsContext::releaseGLSystem()
{
    glXMakeContextCurrent(m_display, None, None, NULL);

    if (m_context)
        glXDestroyContext(m_display, m_context);

    if (m_pbuffer)
        glXDestroyPbuffer(m_display, m_pbuffer);

    if (m_window)
        glXDestroyWindow(m_display, m_window);
}
Example #18
0
void
DestroyPbuffer(Display *dpy, int screen, PBUFFER pbuffer)
{
   int pbSupport = QueryPbuffers(dpy, screen);
#if defined(GLX_VERSION_1_3)
   if (pbSupport == 1) {
      glXDestroyPbuffer(dpy, pbuffer);
      return;
   }
#endif
#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
   if (pbSupport == 2) {
      glXDestroyGLXPbufferSGIX(dpy, pbuffer);
      return;
   }
#endif
}
Example #19
0
                   P3DGLMemoryContextPBuffer::~P3DGLMemoryContextPBuffer
                                      ()
 {
  if (Ok)
   {
    glXDestroyContext(Connection,OffScreenGLXContext);
    glXDestroyPbuffer(Connection,PBuffer);
   }

  if (OwnConnection)
   {
    if (Connection != NULL)
     {
      XCloseDisplay(Connection);
     }
   }
 }
Example #20
0
void XvMCTextures::DeInit(void)
{
    VERBOSE(VB_IMPORTANT, LOC + "DeInit");
    if (!XJ_disp)
        return; // already called

    X11L;
    glXMakeContextCurrent(XJ_disp, None, None, NULL);
    glXDestroyContext(XJ_disp, glx_context); glx_context = 0;
    glXDestroyWindow( XJ_disp, glx_window);  glx_window  = 0;
    glXDestroyPbuffer(XJ_disp, glx_pbuffer); glx_pbuffer = 0;
    XDestroyWindow(   XJ_disp, gl_window);   gl_window   = 0;
    gl_vid_textures.clear();
    gl_osd_textures.clear();
    XJ_disp = NULL;
    X11U;
}
Example #21
0
void SnapshotTaker::cleanupContext(void)
{
	if (pbuffer != 0)
	{
		glXDestroyPbuffer(display, pbuffer);
		pbuffer = 0;
	}
	if (context != NULL)
	{
		glXDestroyContext(display, context);
		context = NULL;
	}
	if (display != NULL)
	{
		XCloseDisplay(display);
		display = NULL;
	}
}
HeadlessView::~HeadlessView() {
    activate();
    clearBuffers();
    deactivate();

#if MBGL_USE_CGL
    CGLDestroyContext(glContext);
#endif

#if MBGL_USE_GLX
    if (glxPbuffer) {
        glXDestroyPbuffer(xDisplay, glxPbuffer);
        glxPbuffer = 0;
    }

    glXDestroyContext(xDisplay, glContext);
#endif
}
Example #23
0
static int
cleanup(void)
{
#if USE_OSMESA
    OSMesaDestroyContext(context);
    free(pbuffer);
#elif USE_CGL
    (void)CGLDestroyContext(context);
    (void)CGLDestroyPBuffer(pbuffer);
#elif USE_GLX
    display = XOpenDisplay(NULL);
    glXDestroyPbuffer(display, pbuffer);
    XCloseDisplay(display);
#else
    /* TODO: cleanup pbuffer and OpenGL context */
#endif
    return 0;
}
DECLEXPORT(EGLBoolean) eglDestroySurface(EGLDisplay hDisplay, EGLSurface hSurface)
{
    Display *pDisplay = (Display *)hDisplay;

    if (!VALID_PTR(hDisplay))
        return setEGLError(EGL_NOT_INITIALIZED);
    switch ((GLXDrawable)hSurface & VBEGL_ANY_SURFACE)
    {
        case VBEGL_WINDOW_SURFACE:
            glXDestroyWindow(pDisplay, (GLXWindow)hSurface & ~VBEGL_WINDOW_SURFACE);
            return clearEGLError();
        case VBEGL_PBUFFER_SURFACE:
            glXDestroyPbuffer(pDisplay, (GLXPbuffer)hSurface & ~VBEGL_PBUFFER_SURFACE);
            return clearEGLError();
        case VBEGL_PIXMAP_SURFACE:
            glXDestroyPixmap(pDisplay, (GLXPixmap)hSurface & ~VBEGL_PIXMAP_SURFACE);
            return clearEGLError();
        default:
            return setEGLError(EGL_BAD_SURFACE);
    }
}
Example #25
0
void CPBO::Destroy (void)
{
if (m_info.hBuf) {
#ifdef _WIN32
	Release ();
	if (m_info.hRC)
		wglDeleteContext (m_info.hRC);
	if (m_info.hDC)
		wglReleasePbufferDCARB (m_info.hBuf, m_info.hDC);
	wglDestroyPbufferARB (m_info.hBuf);
#else //!_WIN32
	if (m_info.hRC)
		glXDestroyContext (m_info.hDC, m_info.hRC);
	if (m_info.hBuf)
		glXDestroyPbuffer (m_info.hDC, m_info.hBuf);
#endif //!_WIN32
	glDeleteTextures (1, &m_info.texId);
	m_info.hRC = NULL;
	m_info.hDC = NULL;
	m_info.hBuf = NULL;
	}
}
Example #26
0
void OglDestroyPBuffer (tPixelBuffer *pb)
{
if (pb->hBuf) {
#ifdef _WIN32
	wglReleaseTexImageARB (pb->hBuf, WGL_FRONT_LEFT_ARB);
	if (pb->hRC)
		wglDeleteContext (pb->hRC);
	if (pb->hDC)
		wglReleasePbufferDCARB (pb->hBuf, pb->hDC);
	wglDestroyPbufferARB (pb->hBuf);
#else //!_WIN32
	if (pb->hRC)
		glXDestroyContext (pb->hDC, pb->hRC);
	if (pb->hBuf)
		glXDestroyPbuffer (pb->hDC, pb->hBuf);
#endif //!_WIN32
	OglDeleteTextures (1, &pb->texId);
	pb->hRC = NULL;
	pb->hDC = NULL;
	pb->hBuf = NULL;
	}
}
Example #27
0
bool               P3DGLMemoryContextPBuffer::Create
                                      (unsigned int        Width,
                                       unsigned int        Height,
                                       bool                NeedAlpha)
 {
  bool                                 Result;
  GLXFBConfig                         *FBConfigList;
  int                                  FBConfigCount;

  Result = true;

  if (Connection == NULL)
   {
    OwnConnection = true;
    Connection = XOpenDisplay(NULL);

    if (Connection == NULL)
     {
      return(false);
     }
   }
  else
   {
    OwnConnection = false;
   }

  Result = true;

  FBConfigList = glXChooseFBConfig( Connection,
                                    DefaultScreen(Connection),
                                    NeedAlpha ? FBAttrsAlphaArray : FBAttrsArray,
                                   &FBConfigCount);


  if (FBConfigList != NULL)
   {
    int            AttrList[8];

    AttrList[0] = GLX_PBUFFER_WIDTH;      AttrList[1] = Width;
    AttrList[2] = GLX_PBUFFER_HEIGHT;     AttrList[3] = Height;
    AttrList[4] = GLX_PRESERVED_CONTENTS; AttrList[5] = True;
    AttrList[6] = None; AttrList[7] = None;

    PBuffer = glXCreatePbuffer(Connection,FBConfigList[0],AttrList);

    /*FIXME: check for errors here */

    OffScreenGLXContext = glXCreateNewContext(Connection,FBConfigList[0],GLX_RGBA_TYPE,NULL,True);

    if (OffScreenGLXContext != NULL)
     {
      Ok = true;

      Result = MakeCurrent();

      if (Result)
       {
        Result = P3DGLExtInit();
       }

      Ok = Result;
     }
    else
     {
      Result = false;
     }

    if (!Result)
     {
      glXDestroyPbuffer(Connection,PBuffer);
     }

    XFree(FBConfigList);
   }
  else
   {
    Result = false;
   }

  if (!Result)
   {
    if (OwnConnection)
     {
      XCloseDisplay(Connection);
     }

    Connection = NULL;
   }

  Ok = Result;

  return(Result);
 }
//----------------------------------------------------------------------------//
OpenGLGLXPBTextureTarget::~OpenGLGLXPBTextureTarget()
{
    if (d_pbuffer)
        glXDestroyPbuffer(d_dpy, d_pbuffer);
}
Example #29
0
int main()
{
#ifdef USE_EGL
	EGLDisplay d = eglGetDisplay(EGL_DEFAULT_DISPLAY);
	if( d )
		printf("eglGetDisplay success!\n");
	else
		printf("eglGetDisplay failed!\n");
	
	int maj, min;
	if( eglInitialize(d, &maj, &min) )
		printf("eglInitialize success!\n");
	else
		printf("eglInitialize failed!\n");
	printf("EGL version = %d.%d\n", maj, min);
	printf("EGL_VENDOR = %s\n", eglQueryString(d, EGL_VENDOR));
	
	EGLConfig first_config;
	EGLint numConfigs;
	eglGetConfigs(d, &first_config, 1, &numConfigs);
	
	if( eglBindAPI(EGL_OPENGL_API) )
		printf("eglBindAPI success!\n");
	else
		printf("eglBindAPI failed!\n");
	
	EGLContext ctx = eglCreateContext(d, first_config, EGL_NO_CONTEXT, NULL);
	if (ctx != EGL_NO_CONTEXT)
		printf("create context success!\n");
	else
		printf("create context failed!\n");

	const EGLint pbufAttribs[] = {
		EGL_WIDTH, width,
		EGL_HEIGHT, height,
		EGL_NONE
	};
	EGLSurface pbuffer = eglCreatePbufferSurface(d, first_config, pbufAttribs);
	if (pbuffer == EGL_NO_SURFACE) {
		printf("failed to create pbuffer!\n");
		return 0;
	}

	EGLBoolean b = eglMakeCurrent(d, pbuffer, pbuffer, ctx);
	if (b)
		printf("make current success!\n");
	else
		printf("make current failed!\n");
#else
	typedef GLXContext (*glXCreateContextAttribsARBProc)(Display*, GLXFBConfig, GLXContext, Bool, const int*);
	typedef Bool (*glXMakeContextCurrentARBProc)(Display*, GLXDrawable, GLXDrawable, GLXContext);
	static glXCreateContextAttribsARBProc
		glXCreateContextAttribsARB = (glXCreateContextAttribsARBProc) glXGetProcAddressARB( (const GLubyte *)"glXCreateContextAttribsARB");
	static glXMakeContextCurrentARBProc
		glXMakeContextCurrentARB   = (glXMakeContextCurrentARBProc)   glXGetProcAddressARB( (const GLubyte *)"glXMakeContextCurrent");
	if(!glXCreateContextAttribsARB)
		std::cout << "glXGetProcAddressARB \"glXCreateContextAttribsARB\" failed!\n";
	if(!glXMakeContextCurrentARB)
		std::cout << "glXGetProcAddressARB \"glXMakeContextCurrentARB\" failed!\n";

	const char *displayName = NULL;
	Display* display = XOpenDisplay( displayName );

	if(!display)
		std::cout << "XOpenDisplay failed!\n";

	static int visualAttribs[] = { None };
	int numberOfFramebufferConfigurations = 0;
	GLXFBConfig* fbConfigs = glXChooseFBConfig( display, DefaultScreen(display), visualAttribs, &numberOfFramebufferConfigurations );

	if(!fbConfigs)
		std::cout << "glXChooseFBConfig failed!\n";

	int context_attribs[] = {
	    None
	};

	GLXContext openGLContext = glXCreateContextAttribsARB( display, fbConfigs[0], 0, True, context_attribs);

	if(!openGLContext)
		std::cout << "glXCreateContextAttribsARB failed!\n";

	int pbufferAttribs[] = {
	    GLX_PBUFFER_WIDTH,  width,
	    GLX_PBUFFER_HEIGHT, height,
	    None
	};
	GLXPbuffer pbuffer = glXCreatePbuffer( display, fbConfigs[0], pbufferAttribs );

	// clean up:
	XFree( fbConfigs );
	XSync( display, False );

	if ( !glXMakeContextCurrent( display, pbuffer, pbuffer, openGLContext ) ){
	    std::cout << "glXMakeContextCurrent failed!\n";
	}
#endif

	std::cout << "OpenGL Version: " << glGetString(GL_VERSION) << ".\n";

	draw_and_save();

#ifdef USE_EGL
	eglDestroySurface(d, pbuffer);
	eglDestroyContext(d, ctx);
	eglTerminate(d);
#else
	glXDestroyPbuffer( display, pbuffer );
	glXDestroyContext( display, openGLContext );
#endif

	return 0;
}
Example #30
0
WindowLessGLContext::~WindowLessGLContext() {
  glXDestroyPbuffer(dpy, pbuf);
  glXDestroyContext(dpy, ctx);
  XCloseDisplay(dpy);
}