GLWidget::GLWidget(QWidget *parent) :
QGLWidget(QGLFormat(QGL::SampleBuffers),parent),
m_camera( new Camera( this ) )
{
setFocusPolicy(Qt::StrongFocus);
glEnable(GL_MULTISAMPLE);
glEnable(GL_STENCIL_FUNC);
simTimer = new QTimer(this);
connect(simTimer, SIGNAL(timeout()), this, SLOT(updateGL()));
simTimer->start(0);
// Initialize the camera position and orientation
m_camera->setPosition( QVector3D( 5.0f, 5.0f, 5.0f ) );
m_camera->setViewCenter( QVector3D( 0.0f, 0.0f, 0.0f ) );
m_camera->setUpVector( QVector3D( 0.0f, 1.0f, 0.0f ) );
QGLFormat glFormat;
glFormat.setVersion( 3, 3 );
glFormat.setProfile( QGLFormat::CoreProfile ); // Requires >=Qt-4.8.0
glFormat.setSampleBuffers( true );
glFormat.setSamples(16);
this->setFormat(glFormat);
scene = new Scene(this);
scene->setCamera(m_camera);
withshadow = true;
}
QT_BEGIN_NAMESPACE
/*!
Returns an OpenGL format for the window format specified by \a format.
*/
QGLFormat QGLFormat::fromSurfaceFormat(const QSurfaceFormat &format)
{
QGLFormat retFormat;
if (format.alphaBufferSize() >= 0)
retFormat.setAlphaBufferSize(format.alphaBufferSize());
if (format.blueBufferSize() >= 0)
retFormat.setBlueBufferSize(format.blueBufferSize());
if (format.greenBufferSize() >= 0)
retFormat.setGreenBufferSize(format.greenBufferSize());
if (format.redBufferSize() >= 0)
retFormat.setRedBufferSize(format.redBufferSize());
if (format.depthBufferSize() >= 0)
retFormat.setDepthBufferSize(format.depthBufferSize());
if (format.samples() > 1) {
retFormat.setSampleBuffers(format.samples());
retFormat.setSamples(true);
}
if (format.stencilBufferSize() > 0) {
retFormat.setStencil(true);
retFormat.setStencilBufferSize(format.stencilBufferSize());
}
retFormat.setDoubleBuffer(format.swapBehavior() != QSurfaceFormat::SingleBuffer);
retFormat.setStereo(format.stereo());
return retFormat;
}
const QGLFormat GLFormat::asQGLFormat() const
{
QGLFormat format;
format.setVersion(m_majorVersion, m_minorVersion);
switch(m_profile)
{
default:
case NoProfile:
format.setProfile(QGLFormat::NoProfile);
break;
case CoreProfile:
format.setProfile(QGLFormat::CoreProfile);
break;
case CompatibilityProfile:
format.setProfile(QGLFormat::CompatibilityProfile);
break;
};
format.setRedBufferSize (m_redBufferSize);
format.setGreenBufferSize (m_greenBufferSize);
format.setBlueBufferSize (m_blueBufferSize);
format.setAlphaBufferSize (m_alphaBufferSize);
format.setDepthBufferSize (m_depthBufferSize);
format.setStencilBufferSize(m_stencilBufferSize);
format.setDoubleBuffer (m_doubleBuffer);
format.setStereo (m_stereo);
format.setSampleBuffers (m_sampleBuffers);
format.setSamples (m_samples);
format.setSwapInterval (m_swapInterval);
return format;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
m_ui(new Ui::MainWindow)
{
m_ui->setupUi(this);
QGLFormat format;
// set the number of samples for multisampling
// will need to enable glEnable(GL_MULTISAMPLE); once we have a context
format.setSamples(4);
#if defined( DARWIN)
// at present mac osx Mountain Lion only supports GL3.2
// the new mavericks will have GL 4.x so can change
format.setVersion(3,2);
#else
// with luck we have the latest GL version so set to this
format.setVersion(4,5);
#endif
// now we are going to set to CoreProfile OpenGL so we can't use and old Immediate mode GL
format.setProfile(QGLFormat::CoreProfile);
// now set the depth buffer to 24 bits
format.setDepthBufferSize(24);
m_gl=new GLWindow(format, this);
m_ui->s_mainWindowGridLayout->addWidget(m_gl,0,0,2,1);
connect(m_ui->m_wireframe,SIGNAL(toggled(bool)),m_gl,SLOT(toggleWireframe(bool)));
}
QT_BEGIN_NAMESPACE
QGLFormat QGLFormat::fromPlatformWindowFormat(const QPlatformWindowFormat &format)
{
QGLFormat retFormat;
retFormat.setAccum(format.accum());
if (format.accumBufferSize() >= 0)
retFormat.setAccumBufferSize(format.accumBufferSize());
retFormat.setAlpha(format.alpha());
if (format.alphaBufferSize() >= 0)
retFormat.setAlphaBufferSize(format.alphaBufferSize());
if (format.blueBufferSize() >= 0)
retFormat.setBlueBufferSize(format.blueBufferSize());
retFormat.setDepth(format.depth());
if (format.depthBufferSize() >= 0)
retFormat.setDepthBufferSize(format.depthBufferSize());
retFormat.setDirectRendering(format.directRendering());
retFormat.setDoubleBuffer(format.doubleBuffer());
if (format.greenBufferSize() >= 0)
retFormat.setGreenBufferSize(format.greenBufferSize());
if (format.redBufferSize() >= 0)
retFormat.setRedBufferSize(format.redBufferSize());
retFormat.setRgba(format.rgba());
retFormat.setSampleBuffers(format.sampleBuffers());
retFormat.setSamples(format.sampleBuffers());
retFormat.setStencil(format.stencil());
if (format.stencilBufferSize() >= 0)
retFormat.setStencilBufferSize(format.stencilBufferSize());
retFormat.setStereo(format.stereo());
retFormat.setSwapInterval(format.swapInterval());
return retFormat;
}
int main(int argc, char **argv)
{
if (argc < 3) {
fprintf(stderr, "Usage: %s <dataname> <ts> <tl>\n", argv[0]);
return EXIT_FAILURE;
}
const std::string dataname = argv[1];
const int ts = atoi(argv[2]),
tl = atoi(argv[3]),
span = 1;
QApplication app(argc, argv);
QGLFormat fmt = QGLFormat::defaultFormat();
fmt.setSampleBuffers(true);
fmt.setSamples(16);
QGLFormat::setDefaultFormat(fmt);
VortexTransition vt;
vt.LoadFromFile(dataname, ts, tl);
vt.ConstructSequence();
CStorylineWidget *widget = new CStorylineWidget;
widget->SetVortexTrasition(&vt);
widget->show();
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QGLFormat glf = QGLFormat::defaultFormat();
glf.setSampleBuffers(true);
glf.setSamples(16);
QGLFormat::setDefaultFormat(glf);
a.setStyle("windowsxp");
std::wstring arg = L"";
#ifdef _WIN32
LPWSTR wideArgText = GetCommandLineW();
int wArgc;
LPWSTR *wideArgs = CommandLineToArgvW(wideArgText, &wArgc);
if (wArgc == 2) {
arg = wideArgs[1];
}
#endif
MainWindow *w = new MainWindow(arg);
w->show();
int exec = a.exec();
delete w;
#ifdef _WIN32
LocalFree(wideArgs);
#endif
return exec;
}
void *
figure::f_main_loop(void) {
QApplication * _pc_app;
int i_argc = 1;
char * ppc_argv[2] = { (char*) "toto", (char*) "ttut" };
cout << "Creating app " << pthread_self() << endl;
figure_app c_app(i_argc, ppc_argv);
#if 1
QGLFormat glf = QGLFormat::defaultFormat();
glf.setSampleBuffers(true);
glf.setSamples(4);
QGLFormat::setDefaultFormat(glf);
#endif
c_app.f_new_window(_pc_core);
//cout << "core: " <<_pc_core << endl;
//glplot::window *_pc_win = new glplot::window(_pc_core);
/* Affichage de notre premiere fenêtre de rendu OpenGL */
//_pc_win->show();
/* Registring application pointer */
_pv_app = &c_app;
/* Running QT Main LOOP */
c_app.exec();
}
//! [0]
GLWidgetShader::GLWidgetShader(QWidget *parent)
: QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
{
glEnable(GL_MULTISAMPLE);
// Important to enable the shaders
QGLFormat rgbaformat;
rgbaformat.setRgba(true);
rgbaformat.setSampleBuffers(true);
rgbaformat.setDoubleBuffer(true);
rgbaformat.setSamples(4);
rgbaformat.setOverlay(0);
this->setFormat(rgbaformat);
this->makeCurrent();
// Very important
this->setAutoFillBackground(false);
QTimer *timer = new QTimer(this);
timer->start(15);
timer->setInterval(15);
QObject::connect(timer,SIGNAL(timeout()),this,SLOT(repaint()));
this->isDrawing=false;
qglClearColor(Qt::white);
this->nVertices = 0;
}
void SkGLWidget::setSampleCount(int sampleCount)
{
QGLFormat currentFormat = format();
currentFormat.setSampleBuffers(sampleCount > 0);
currentFormat.setSamples(sampleCount);
setFormat(currentFormat);
}
int main(int argc, char **argv)
{
std::string filename_vortex, filename_trace;
if (argc == 1) {
fprintf(stderr, "Usage: %s <vortex_file> [trace_file]\n", argv[0]);
return EXIT_FAILURE;
}
if (argc >= 2) filename_vortex = argv[1];
if (argc >= 3) filename_trace = argv[2];
QApplication app(argc, argv);
// glutInit(&argc, argv);
QGLFormat fmt = QGLFormat::defaultFormat();
fmt.setSampleBuffers(true);
fmt.setSamples(16);
QGLFormat::setDefaultFormat(fmt);
CGLWidget *widget = new CGLWidget;
widget->show();
widget->LoadVortexLines(filename_vortex);
// widget->LoadVortexOjbectsFromTextFile(filename_vortex);
widget->LoadFieldLines(filename_trace);
return app.exec();
}
bool wzMainScreenSetup(int antialiasing, bool fullscreen, bool vsync, bool highDPI)
{
debug(LOG_MAIN, "Qt initialization");
//QGL::setPreferredPaintEngine(QPaintEngine::OpenGL); // Workaround for incorrect text rendering on many platforms, doesn't exist in Qt5…
// Register custom WZ app event type
wzAppQEventType = QEvent::registerEventType();
// Setting up OpenGL
QGLFormat format;
format.setDoubleBuffer(true);
//format.setAlpha(true);
int w = pie_GetVideoBufferWidth();
int h = pie_GetVideoBufferHeight();
if (antialiasing)
{
format.setSampleBuffers(true);
format.setSamples(antialiasing);
}
mainWindowPtr = new WzMainWindow(QSize(w, h), format, wzAppQEventType.load());
WzMainWindow &mainwindow = *(mainWindowPtr.load());
mainwindow.setMinimumResolution(QSize(800, 600));
if (!mainwindow.context()->isValid())
{
QMessageBox::critical(nullptr, "Oops!", "Warzone2100 failed to create an OpenGL context. This probably means that your graphics drivers are out of date. Try updating them!");
return false;
}
screenWidth = w;
screenHeight = h;
if (fullscreen)
{
mainwindow.resize(w, h);
mainwindow.showFullScreen();
if (w > mainwindow.width())
{
w = mainwindow.width();
}
if (h > mainwindow.height())
{
h = mainwindow.height();
}
pie_SetVideoBufferWidth(w);
pie_SetVideoBufferHeight(h);
}
else
{
mainwindow.show();
mainwindow.setMinimumSize(w, h);
mainwindow.setMaximumSize(w, h);
}
mainwindow.setSwapInterval(vsync);
mainwindow.setReadyToPaint();
return true;
}
Viewer::Viewer(QWidget* parent)
: QGLViewer(CGAL::Qt::createOpenGLContext(),parent), wireframe(false), flatShading(true),
edges(true), vertices(true), m_displayListCreated(false)
{
QGLFormat newFormat = this->format();
newFormat.setSampleBuffers(true);
newFormat.setSamples(16);
this->setFormat(newFormat);
are_buffers_initialized = false;
}
bool wzMain2()
{
debug(LOG_MAIN, "Qt initialization");
QGL::setPreferredPaintEngine(QPaintEngine::OpenGL); // Workaround for incorrect text rendering on nany platforms.
// Setting up OpenGL
QGLFormat format;
format.setDoubleBuffer(true);
format.setAlpha(true);
int w = pie_GetVideoBufferWidth();
int h = pie_GetVideoBufferHeight();
if (war_getFSAA())
{
format.setSampleBuffers(true);
format.setSamples(war_getFSAA());
}
mainWindowPtr = new WzMainWindow(QSize(w, h), format);
WzMainWindow &mainwindow = *mainWindowPtr;
mainwindow.setMinimumResolution(QSize(800, 600));
if (!mainwindow.context()->isValid())
{
QMessageBox::critical(NULL, "Oops!", "Warzone2100 failed to create an OpenGL context. This probably means that your graphics drivers are out of date. Try updating them!");
return false;
}
screenWidth = w;
screenHeight = h;
if (war_getFullscreen())
{
mainwindow.resize(w,h);
mainwindow.showFullScreen();
if(w>mainwindow.width()) {
w = mainwindow.width();
}
if(h>mainwindow.height()) {
h = mainwindow.height();
}
pie_SetVideoBufferWidth(w);
pie_SetVideoBufferHeight(h);
}
else
{
mainwindow.show();
mainwindow.setMinimumSize(w, h);
mainwindow.setMaximumSize(w, h);
}
mainwindow.setSwapInterval(war_GetVsync());
war_SetVsync(mainwindow.swapInterval() > 0);
mainwindow.setReadyToPaint();
return true;
}
int main(int argc, char *argv[])
{
//Eigen::initParallel();
QApplication a(argc, argv);
QGLFormat glf = QGLFormat::defaultFormat();
glf.setSampleBuffers(true);
glf.setSamples(16);
QGLFormat::setDefaultFormat(glf);
BVHApp w;
w.show();
return a.exec();
}
glViewer::glViewer(QWidget *parent, int Width, int Height):QGLWidget(parent)
{
QGLFormat format;
format.setDoubleBuffer(true);
format.setSampleBuffers(true);
format.setSamples(32);
format.setDirectRendering(true);
setFormat(format);
//glEnable();
//setAutoFillBackground(true);
setFixedSize(Width, Height);
move(0,0);
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QGLFormat glf = QGLFormat::defaultFormat();
glf.setSampleBuffers(true);
glf.setSamples(4);
QGLFormat::setDefaultFormat(glf);
QFile file("://style.css");
file.open(QIODevice::ReadOnly);
a.setStyleSheet(file.readAll());
MainWidget w;
w.show();
return a.exec();
}
int main(int argc, char *argv[])
{
//add a bootstrap config file
//multisampling
QGLFormat fmt;
fmt.setSampleBuffers(true);
fmt.setSamples(16);
QGLFormat::setDefaultFormat(fmt);
QApplication a(argc, argv);
MyProject w;
w.show();
a.connect(&a, SIGNAL(lastWindowClosed()), &a, SLOT(quit()));
return a.exec();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QGLFormat glf = QGLFormat::defaultFormat();
glf.setSampleBuffers(true);
glf.setSamples(4);
QGLFormat::setDefaultFormat(glf);
// QStyle *arthurStyle = new ArthurStyle();
MainWindow mainWin;
// mainWin.setStyle(arthurStyle);
mainWin.show();
return app.exec();
}
/* this code runs the basic main window and is created by the Qt Creator app */
int main(int argc, char *argv[])
{
// make an instance of the QApplication
QApplication a(argc, argv);
QGLFormat glf = QGLFormat::defaultFormat();
glf.setSampleBuffers(true);
glf.setSamples(4);
QGLFormat::setDefaultFormat(glf);
// Create a new MainWindow
MainWindow w;
// show it
w.show();
// hand control over to Qt framework
return a.exec();
}
int main(int argc, char *argv[])
{
QApplication::setColorSpec( QApplication::CustomColor );
QApplication app(argc, argv);
app.setWindowIcon(QIcon("icon.png"));
///*
QGLFormat glf = QGLFormat::defaultFormat();
glf.setSampleBuffers(true);
glf.setSamples(4);
QGLFormat::setDefaultFormat(glf);
//*/
MainWindow mainwin;
mainwin.show();
return app.exec();
}
GRenderWindow::GRenderWindow(QWidget* parent) : QWidget(parent), emu_thread(this)
{
// TODO: One of these flags might be interesting: WA_OpaquePaintEvent, WA_NoBackground, WA_DontShowOnScreen, WA_DeleteOnClose
QGLFormat fmt;
fmt.setProfile(QGLFormat::CoreProfile);
fmt.setVersion(3,2);
fmt.setSampleBuffers(true);
fmt.setSamples(4);
child = new GGLWidgetInternal(fmt, this);
QBoxLayout* layout = new QHBoxLayout(this);
resize(VideoCore::kScreenTopWidth, VideoCore::kScreenTopHeight + VideoCore::kScreenBottomHeight);
layout->addWidget(child);
layout->setMargin(0);
setLayout(layout);
BackupGeometry();
}
int main(int argc, char** argv)
{
#if !defined USE_SWRAST
QGLFormat fmt;
fmt.setSampleBuffers(true);
fmt.setSamples(16); // 2, 4, 8, 16
QGLFormat::setDefaultFormat(fmt);
#endif
QApplication app(argc, argv);
#if defined USE_FORCE_GL
app.setAttribute(Qt::AA_UseDesktopOpenGL);
#endif
MainWindow w; // главное окно
w.show();
if(!w.fr->isActiveWindow())
w.fr->activateWindow();
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
DEFAULT_FILE_PATH = "";
// Anti-aliasing
QGLFormat glf = QGLFormat::defaultFormat();
glf.setSamples(8);
QGLFormat::setDefaultFormat(glf);
// Create main window
Workspace w;
w.move(QApplication::desktop()->availableGeometry().center() - w.rect().center());
w.show();
w.addNewScene();
return a.exec();
}
Viewer::Viewer(QWidget *parent) : QGLWidget(parent), isReady(false)
{
// Anti-aliasing when using QGLWidget or subclasses
if( false )
{
QGLFormat glf = QGLFormat::defaultFormat();
glf.setSamples(8);
this->setFormat(glf);
}
// Rotate
if( true )
{
timer = new QTimer();
QObject::connect(timer, &QTimer::timeout, [=]() {t += 0.01;this->update(); emit( viewChanged() );});
//timer->start(200);
}
xRot = yRot = zRot = 0;
}
void ConfigManager::Initialize() {
QGLFormat glf = QGLFormat::defaultFormat();
glf.setRedBufferSize(8);
glf.setGreenBufferSize(8);
glf.setBlueBufferSize(8);
glf.setAlphaBufferSize(8);
glf.setSampleBuffers(true);
glf.setSamples(8);
glf.setDepth(true);
glf.setDepthBufferSize(24);
glf.setVersion(3, 3);
glf.setProfile(QGLFormat::CompatibilityProfile);
glf.setSwapInterval(1);
QGLFormat::setDefaultFormat(glf);
input_state_ = InputState::SELECT;
snap_to_grid_ = true;
grid_minor_color_ = QColor(175, 175, 175);
grid_major_color_ = QColor(75, 75, 75);
}
QGLFormat core_format () {
QGLFormat f (QGL::DoubleBuffer | QGL::DepthBuffer | QGL::Rgba);
int swap_interval = MR::File::Config::get_int ("VSync", 0);
f.setSwapInterval (swap_interval);
bool need_core_profile =
#ifdef MRTRIX_MACOSX
true;
#else
false;
#endif
if (File::Config::get_bool ("NeedOpenGLCoreProfile", need_core_profile)) {
f.setVersion (3,3);
f.setProfile (QGLFormat::CoreProfile);
}
int nsamples = File::Config::get_int ("MSAA", 0);
if (nsamples > 1) {
f.setSampleBuffers (true);
f.setSamples (nsamples);
}
return f;
}
// Updates "format" with the parameters of the selected configuration.
void qt_glformat_from_eglconfig(QGLFormat& format, const EGLConfig config)
{
EGLint redSize = 0;
EGLint greenSize = 0;
EGLint blueSize = 0;
EGLint alphaSize = 0;
EGLint depthSize = 0;
EGLint stencilSize = 0;
EGLint sampleCount = 0;
EGLint level = 0;
EGLDisplay display = QEgl::display();
eglGetConfigAttrib(display, config, EGL_RED_SIZE, &redSize);
eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &greenSize);
eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &blueSize);
eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &alphaSize);
eglGetConfigAttrib(display, config, EGL_DEPTH_SIZE, &depthSize);
eglGetConfigAttrib(display, config, EGL_STENCIL_SIZE, &stencilSize);
eglGetConfigAttrib(display, config, EGL_SAMPLES, &sampleCount);
eglGetConfigAttrib(display, config, EGL_LEVEL, &level);
format.setRedBufferSize(redSize);
format.setGreenBufferSize(greenSize);
format.setBlueBufferSize(blueSize);
format.setAlphaBufferSize(alphaSize);
format.setDepthBufferSize(depthSize);
format.setStencilBufferSize(stencilSize);
format.setSamples(sampleCount);
format.setPlane(level);
format.setDirectRendering(true); // All EGL contexts are direct-rendered
format.setRgba(true); // EGL doesn't support colour index rendering
format.setStereo(false); // EGL doesn't support stereo buffers
format.setAccumBufferSize(0); // EGL doesn't support accululation buffers
format.setDoubleBuffer(true); // We don't support single buffered EGL contexts
// Clear the EGL error state because some of the above may
// have errored out because the attribute is not applicable
// to the surface type. Such errors don't matter.
eglGetError();
}
GLView * GLView::create( NifSkope * window )
{
QGLFormat fmt;
static QList<QPointer<GLView> > views;
QGLWidget * share = nullptr;
for ( const QPointer<GLView>& v : views ) {
if ( v )
share = v;
}
// All new windows after the first window will share a format
if ( share ) {
fmt = share->format();
} else {
fmt.setSampleBuffers( Options::antialias() );
}
// OpenGL version
fmt.setVersion( 2, 1 );
// Ignored if version < 3.2
//fmt.setProfile(QGLFormat::CoreProfile);
// V-Sync
fmt.setSwapInterval( 1 );
fmt.setDoubleBuffer( true );
fmt.setSamples( Options::antialias() ? 16 : 0 );
fmt.setDirectRendering( true );
fmt.setRgba( true );
views.append( QPointer<GLView>( new GLView( fmt, window, share ) ) );
return views.last();
}
QGLGraphicsSystem::QGLGraphicsSystem(bool useX11GL)
: QGraphicsSystem(), m_useX11GL(useX11GL)
{
#if defined(Q_WS_X11) && !defined(QT_OPENGL_ES)
// only override the system defaults if the user hasn't already
// picked a visual
if (X11->visual == 0 && X11->visual_id == -1 && X11->visual_class == -1) {
// find a double buffered, RGBA visual that supports OpenGL
// and set that as the default visual for windows in Qt
int i = 0;
int spec[16];
spec[i++] = GLX_RGBA;
spec[i++] = GLX_DOUBLEBUFFER;
if (!qgetenv("QT_GL_SWAPBUFFER_PRESERVE").isNull()) {
spec[i++] = GLX_DEPTH_SIZE;
spec[i++] = 8;
spec[i++] = GLX_STENCIL_SIZE;
spec[i++] = 8;
spec[i++] = GLX_SAMPLE_BUFFERS_ARB;
spec[i++] = 1;
spec[i++] = GLX_SAMPLES_ARB;
spec[i++] = 4;
}
spec[i++] = XNone;
XVisualInfo *vi = glXChooseVisual(X11->display, X11->defaultScreen, spec);
if (vi) {
X11->visual_id = vi->visualid;
X11->visual_class = vi->c_class;
QGLFormat format;
int res;
glXGetConfig(X11->display, vi, GLX_LEVEL, &res);
format.setPlane(res);
glXGetConfig(X11->display, vi, GLX_DOUBLEBUFFER, &res);
format.setDoubleBuffer(res);
glXGetConfig(X11->display, vi, GLX_DEPTH_SIZE, &res);
format.setDepth(res);
if (format.depth())
format.setDepthBufferSize(res);
glXGetConfig(X11->display, vi, GLX_RGBA, &res);
format.setRgba(res);
glXGetConfig(X11->display, vi, GLX_RED_SIZE, &res);
format.setRedBufferSize(res);
glXGetConfig(X11->display, vi, GLX_GREEN_SIZE, &res);
format.setGreenBufferSize(res);
glXGetConfig(X11->display, vi, GLX_BLUE_SIZE, &res);
format.setBlueBufferSize(res);
glXGetConfig(X11->display, vi, GLX_ALPHA_SIZE, &res);
format.setAlpha(res);
if (format.alpha())
format.setAlphaBufferSize(res);
glXGetConfig(X11->display, vi, GLX_ACCUM_RED_SIZE, &res);
format.setAccum(res);
if (format.accum())
format.setAccumBufferSize(res);
glXGetConfig(X11->display, vi, GLX_STENCIL_SIZE, &res);
format.setStencil(res);
if (format.stencil())
format.setStencilBufferSize(res);
glXGetConfig(X11->display, vi, GLX_STEREO, &res);
format.setStereo(res);
glXGetConfig(X11->display, vi, GLX_SAMPLE_BUFFERS_ARB, &res);
format.setSampleBuffers(res);
if (format.sampleBuffers()) {
glXGetConfig(X11->display, vi, GLX_SAMPLES_ARB, &res);
format.setSamples(res);
}
QGLWindowSurface::surfaceFormat = format;
XFree(vi);
printf("using visual class %x, id %x\n", X11->visual_class, X11->visual_id);
}
}
#elif defined(Q_WS_WIN)
QGLWindowSurface::surfaceFormat.setDoubleBuffer(true);
qt_win_owndc_required = true;
#endif
}