gecko-dev/gfx/gl/GLXLibrary.h

/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef GFX_GLXLIBRARY_H
#define GFX_GLXLIBRARY_H

#include "GLContextTypes.h"
#include "prlink.h"
typedef realGLboolean GLboolean;

// stuff from glx.h
#include "X11/Xlib.h"
typedef struct __GLXcontextRec* GLXContext;
typedef XID GLXPixmap;
typedef XID GLXDrawable;
/* GLX 1.3 and later */
typedef struct __GLXFBConfigRec* GLXFBConfig;
// end of stuff from glx.h
#include "prenv.h"

struct PRLibrary;
class gfxASurface;

namespace mozilla {
namespace gl {

class GLXLibrary
{
public:
    GLXLibrary()
        : mSymbols{nullptr}
        , mInitialized(false)
        , mTriedInitializing(false)
        , mUseTextureFromPixmap(false)
        , mDebug(false)
        , mHasRobustness(false)
        , mHasCreateContextAttribs(false)
        , mHasVideoSync(false)
        , mIsATI(false), mIsNVIDIA(false)
        , mClientIsMesa(false)
        , mOGLLibrary(nullptr)
    {}

    void xDestroyContext(Display* display, GLXContext context);
    Bool xMakeCurrent(Display* display,
                      GLXDrawable drawable,
                      GLXContext context);

    GLXContext xGetCurrentContext();
    GLXFBConfig* xChooseFBConfig(Display* display,
                                 int screen,
                                 const int* attrib_list,
                                 int* nelements);
    GLXFBConfig* xGetFBConfigs(Display* display,
                               int screen,
                               int* nelements);
    GLXContext xCreateNewContext(Display* display,
                                 GLXFBConfig config,
                                 int render_type,
                                 GLXContext share_list,
                                 Bool direct);
    int xGetFBConfigAttrib(Display* display,
                           GLXFBConfig config,
                           int attribute,
                           int* value);
    void xSwapBuffers(Display* display, GLXDrawable drawable);
    const char* xQueryExtensionsString(Display* display,
                                       int screen);
    const char* xGetClientString(Display* display,
                                 int screen);
    const char* xQueryServerString(Display* display,
                                   int screen, int name);
    GLXPixmap xCreatePixmap(Display* display,
                            GLXFBConfig config,
                            Pixmap pixmap,
                            const int* attrib_list);
    GLXPixmap xCreateGLXPixmapWithConfig(Display* display,
                                         GLXFBConfig config,
                                         Pixmap pixmap);
    void xDestroyPixmap(Display* display, GLXPixmap pixmap);
    Bool xQueryVersion(Display* display,
                       int* major,
                       int* minor);
    void xBindTexImage(Display* display,
                       GLXDrawable drawable,
                       int buffer,
                       const int* attrib_list);
    void xReleaseTexImage(Display* display,
                          GLXDrawable drawable,
                          int buffer);
    void xWaitGL();
    void xWaitX();

    GLXContext xCreateContextAttribs(Display* display,
                                     GLXFBConfig config,
                                     GLXContext share_list,
                                     Bool direct,
                                     const int* attrib_list);

    int xGetVideoSync(unsigned int* count);
    int xWaitVideoSync(int divisor, int remainder, unsigned int* count);
    void xSwapInterval(Display* dpy, GLXDrawable drawable, int interval);

    bool EnsureInitialized();

    GLXPixmap CreatePixmap(gfxASurface* aSurface);
    void DestroyPixmap(Display* aDisplay, GLXPixmap aPixmap);
    void BindTexImage(Display* aDisplay, GLXPixmap aPixmap);
    void ReleaseTexImage(Display* aDisplay, GLXPixmap aPixmap);
    void UpdateTexImage(Display* aDisplay, GLXPixmap aPixmap);

    bool UseTextureFromPixmap() { return mUseTextureFromPixmap; }
    bool HasRobustness() { return mHasRobustness; }
    bool HasCreateContextAttribs() { return mHasCreateContextAttribs; }
    bool SupportsTextureFromPixmap(gfxASurface* aSurface);
    bool SupportsVideoSync();
    bool SupportsSwapControl() const { return bool(mSymbols.fSwapIntervalEXT); }
    bool IsATI() { return mIsATI; }
    bool IsMesa() { return mClientIsMesa; }

    PRFuncPtr GetGetProcAddress() const {
        return (PRFuncPtr)mSymbols.fGetProcAddress;
    }

private:
    struct {
        void         (GLAPIENTRY *fDestroyContext) (Display*, GLXContext);
        Bool         (GLAPIENTRY *fMakeCurrent) (Display*, GLXDrawable, GLXContext);
        GLXContext   (GLAPIENTRY *fGetCurrentContext) ();
        void*        (GLAPIENTRY *fGetProcAddress) (const char*);
        GLXFBConfig* (GLAPIENTRY *fChooseFBConfig) (Display*, int, const int*, int*);
        GLXFBConfig* (GLAPIENTRY *fGetFBConfigs) (Display*, int, int*);
        GLXContext   (GLAPIENTRY *fCreateNewContext) (Display*, GLXFBConfig, int,
                                                      GLXContext, Bool);
        int          (GLAPIENTRY *fGetFBConfigAttrib) (Display*, GLXFBConfig, int, int*);
        void         (GLAPIENTRY *fSwapBuffers) (Display*, GLXDrawable);
        const char*  (GLAPIENTRY *fQueryExtensionsString) (Display*, int);
        const char*  (GLAPIENTRY *fGetClientString) (Display*, int);
        const char*  (GLAPIENTRY *fQueryServerString) (Display*, int, int);
        GLXPixmap    (GLAPIENTRY *fCreatePixmap) (Display*, GLXFBConfig, Pixmap,
                                                  const int*);
        GLXPixmap    (GLAPIENTRY *fCreateGLXPixmapWithConfig) (Display*, GLXFBConfig,
                                                              Pixmap);
        void         (GLAPIENTRY *fDestroyPixmap) (Display*, GLXPixmap);
        Bool         (GLAPIENTRY *fQueryVersion) (Display*, int*, int*);
        void         (GLAPIENTRY *fWaitGL) ();
        void         (GLAPIENTRY *fWaitX) ();
        void         (GLAPIENTRY *fBindTexImageEXT) (Display*, GLXDrawable, int,
                                                     const int*);
        void         (GLAPIENTRY *fReleaseTexImageEXT) (Display*, GLXDrawable, int);
        GLXContext   (GLAPIENTRY *fCreateContextAttribsARB) (Display*, GLXFBConfig,
                                                             GLXContext, Bool,
                                                             const int*);
        int          (GLAPIENTRY *fGetVideoSyncSGI) (unsigned int*);
        int          (GLAPIENTRY *fWaitVideoSyncSGI) (int, int, unsigned int*);
        void         (GLAPIENTRY *fSwapIntervalEXT) (Display*, GLXDrawable, int);
    } mSymbols;

#ifdef DEBUG
    void BeforeGLXCall();
    void AfterGLXCall();
#endif

    bool mInitialized;
    bool mTriedInitializing;
    bool mUseTextureFromPixmap;
    bool mDebug;
    bool mHasRobustness;
    bool mHasCreateContextAttribs;
    bool mHasVideoSync;
    bool mIsATI;
    bool mIsNVIDIA;
    bool mClientIsMesa;
    PRLibrary* mOGLLibrary;
};

// a global GLXLibrary instance
extern GLXLibrary sGLXLibrary;

} /* namespace gl */
} /* namespace mozilla */
#endif /* GFX_GLXLIBRARY_H */