用opengl在x11系统上用GL/ GL .h和GL/ GL .h绘制三角形

Question

我已经阅读并拼凑了多个项目，以便创建一个x11窗口与打开gl工作，与预安装的gl/gl.h和gl/glx.h。我遇到的问题是，我想要画到屏幕上的三角形没有显示出来。我想的是我没有设置任何投影参数等，或者三角形没有被绘制到我想要绘制的空间。

我得到一个窗口，我能够设置触发后，我已经订阅了事件掩码xevents。按下"esc"键将触发一个事件，该事件最终将调用Shutdown()并打破循环，释放x11和gl内容，最后退出程序。所以唯一不能工作的是绘图到屏幕的东西，这基本上是我的程序的重点。

如何解决这个问题?

main.cpp:

#include <cstring>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/keysymdef.h>
#include <GL/gl.h>
#include <GL/glx.h>
#include <sys/time.h>
#include <unistd.h>
#define WINDOW_WIDTH    800
#define WINDOW_HEIGHT   600
#define FPS 30
#define TEST_LOCAL
int shutdown = 0;
extern bool Initialize(int w, int h);
extern bool Update(float deltaTime);
extern void Render();
extern void HandleKeyboardEvents( XEvent );
extern void Resize(int w, int h);
extern void Shutdown();
typedef GLXContext (*glXCreateContextAttribsARBProc)(Display*, GLXFBConfig, GLXContext, Bool, const int*);
#define SKIP_TICKS      (1000 / FPS)
static double GetMilliseconds() {
static timeval s_tTimeVal;
gettimeofday(&s_tTimeVal, NULL);
double time = s_tTimeVal.tv_sec * 1000.0; // sec to ms
time += s_tTimeVal.tv_usec / 1000.0; // us to ms
return time;
}
static bool isExtensionSupported(const char *extList, const char *extension) {
return strstr(extList, extension) != 0;
}
int main(int argc, char** argv) {
Display* display;
Window window;
Screen* screen;
int screenId;
XEvent ev;
// Open the display
display = XOpenDisplay(NULL);
if (display == NULL) {
std::cout << "Could not open displayn";
return 1;
}
screen = DefaultScreenOfDisplay(display);
screenId = DefaultScreen(display);

// Check GLX version
GLint majorGLX, minorGLX = 0;
glXQueryVersion(display, &majorGLX, &minorGLX);
if (majorGLX <= 1 && minorGLX < 2) {
std::cout << "GLX 1.2 or greater is required.n";
XCloseDisplay(display);
return 1;
}
GLint glxAttribs[] = {
GLX_X_RENDERABLE    , True,
GLX_DRAWABLE_TYPE   , GLX_WINDOW_BIT,
GLX_RENDER_TYPE     , GLX_RGBA_BIT,
GLX_X_VISUAL_TYPE   , GLX_TRUE_COLOR,
GLX_RED_SIZE        , 8,
GLX_GREEN_SIZE      , 8,
GLX_BLUE_SIZE       , 8,
GLX_ALPHA_SIZE      , 8,
GLX_DEPTH_SIZE      , 24,
GLX_STENCIL_SIZE    , 8,
GLX_DOUBLEBUFFER    , True,
None
};

int fbcount;
GLXFBConfig* fbc = glXChooseFBConfig(display, screenId, glxAttribs, &fbcount);
if (fbc == 0) {
std::cout << "Failed to retrieve framebuffer.n";
XCloseDisplay(display);
return 1;
}
// Pick the FB config/visual with the most samples per pixel
int best_fbc = -1, worst_fbc = -1, best_num_samp = -1, worst_num_samp = 999;
for (int i = 0; i < fbcount; ++i) {
XVisualInfo *vi = glXGetVisualFromFBConfig( display, fbc[i] );
if ( vi != 0) {
int samp_buf, samples;
glXGetFBConfigAttrib( display, fbc[i], GLX_SAMPLE_BUFFERS, &samp_buf );
glXGetFBConfigAttrib( display, fbc[i], GLX_SAMPLES       , &samples  );
if ( best_fbc < 0 || (samp_buf && samples > best_num_samp) ) {
best_fbc = i;
best_num_samp = samples;
}
if ( worst_fbc < 0 || !samp_buf || samples < worst_num_samp )
worst_fbc = i;
worst_num_samp = samples;
}
XFree( vi );
}
GLXFBConfig bestFbc = fbc[ best_fbc ];
XFree( fbc ); // Make sure to free this!

XVisualInfo* visual = glXGetVisualFromFBConfig( display, bestFbc );
if (visual == 0) {
std::cout << "Could not create correct visual window.n";
XCloseDisplay(display);
return 1;
}

if (screenId != visual->screen) {
std::cout << "screenId(" << screenId << ") does not match visual->screen(" << visual->screen << ").n";
XCloseDisplay(display);
return 1;
}
// Open the window
XSetWindowAttributes windowAttribs;
windowAttribs.border_pixel = BlackPixel(display, screenId);
windowAttribs.background_pixel = WhitePixel(display, screenId);
windowAttribs.override_redirect = True;
windowAttribs.colormap = XCreateColormap(display, RootWindow(display, screenId), visual->visual, AllocNone);
windowAttribs.event_mask = ExposureMask;
window = XCreateWindow(display, RootWindow(display, screenId), 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, visual->depth, InputOutput, visual->visual, CWBackPixel | CWColormap | CWBorderPixel | CWEventMask, &windowAttribs);
// Redirect Close
Atom atomWmDeleteWindow = XInternAtom(display, "WM_DELETE_WINDOW", False);
XSetWMProtocols(display, window, &atomWmDeleteWindow, 1);
// Create GLX OpenGL context
glXCreateContextAttribsARBProc glXCreateContextAttribsARB = 0;
glXCreateContextAttribsARB = (glXCreateContextAttribsARBProc) glXGetProcAddressARB( (const GLubyte *) "glXCreateContextAttribsARB" );

int context_attribs[] = {
GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
GLX_CONTEXT_MINOR_VERSION_ARB, 2,
GLX_CONTEXT_FLAGS_ARB, GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
None
};
GLXContext context = 0;
const char *glxExts = glXQueryExtensionsString( display,  screenId );
if (!isExtensionSupported( glxExts, "GLX_ARB_create_context")) {
std::cout << "GLX_ARB_create_context not supportedn";
context = glXCreateNewContext( display, bestFbc, GLX_RGBA_TYPE, 0, True );
}
else {
context = glXCreateContextAttribsARB( display, bestFbc, 0, true, context_attribs );
}
XSync( display, False );
// Verifying that context is a direct context
if (!glXIsDirect (display, context)) {
std::cout << "Indirect GLX rendering context obtainedn";
}
else {
std::cout << "Direct GLX rendering context obtainedn";
}
glXMakeCurrent(display, window, context);
std::cout << "GL Renderer: " << glGetString(GL_RENDERER) << "n";
std::cout << "GL Version: " << glGetString(GL_VERSION) << "n";
std::cout << "GLSL Version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << "n";
if (!Initialize(WINDOW_WIDTH, WINDOW_HEIGHT)) {
glXDestroyContext(display, context);
XFree(visual);
XFreeColormap(display, windowAttribs.colormap);
XDestroyWindow(display, window);
XCloseDisplay(display);
return 1;
}
glMatrixMode( GL_PROJECTION );
glOrtho( 0, 640, 480, 0, -1, 1 );
XSelectInput( display, window, PointerMotionMask | ButtonPressMask | ButtonReleaseMask | KeyPressMask );
// Show the window
XClearWindow(display, window);
XMapRaised(display, window);
double prevTime = GetMilliseconds();
double currentTime = GetMilliseconds();
double deltaTime = 0.0;
timeval time;
long sleepTime = 0;
gettimeofday(&time, NULL);
long nextGameTick = (time.tv_sec * 1000) + (time.tv_usec / 1000);
// Enter message loop
while (shutdown != 1) {
if (XPending(display) > 0) {
XNextEvent(display, &ev);
if (ev.type == Expose) {
XWindowAttributes attribs;
XGetWindowAttributes(display, window, &attribs);
Resize(attribs.width, attribs.height);
}
if (ev.type == ClientMessage) {
if (ev.xclient.data.l[0] == atomWmDeleteWindow) {
break;
}
}
else if (ev.type == DestroyNotify) { 
break;
}
}
currentTime = GetMilliseconds();
deltaTime = double(currentTime - prevTime) * 0.001;
prevTime = currentTime;
if (!Update((float)deltaTime)) {
break;
}
HandleKeyboardEvents( ev );
Render();
// Present frame
glXSwapBuffers(display, window);
// Limit Framerate
gettimeofday(&time, NULL);
nextGameTick += SKIP_TICKS;
sleepTime = nextGameTick - ((time.tv_sec * 1000) + (time.tv_usec / 1000));
usleep((unsigned int)(sleepTime / 1000));
}
std::cout << "Shutting Downn";
Shutdown();
// Cleanup GLX
glXDestroyContext(display, context);
// Cleanup X11
XFree(visual);
XFreeColormap(display, windowAttribs.colormap);
XDestroyWindow(display, window);
XCloseDisplay(display);
return 0;
}
#ifdef TEST_LOCAL
bool Initialize(int w, int h) {
glClearColor(0.5f, 0.6f, 0.7f, 1.0f);
glViewport(0, 0, w, h);
return true;
}
bool Update(float deltaTime) {
return true;
}
void HandleKeyboardEvents( XEvent ev ) {
int x, y;
switch ( ev.type ) {
case ButtonPress:
if ( ev.xbutton.button == 1 ) {
std::cout << "Left mouse down n";
}
break;
case ButtonRelease:
if ( ev.xbutton.button == 1 ) {
std::cout << "Left mouse up n";
}
break;
case KeyPress:
if ( ev.xkey.keycode == 9 ) { // ESC
Shutdown();
}
break;
case MotionNotify:
x = ev.xmotion.x;
y = ev.xmotion.y;
//std::cout << "Mouse X:" << x << ", Y: " << y << "n";
break;  
}
}
void Render() {
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLES);
glColor3f(  1.0f,  0.0f, 0.0f);
glVertex3f( 0.0f, -1.0f, 0.0f);
glColor3f(  1.0f,  0.0f, 0.0f);
glVertex3f(-1.0f,  1.0f, 0.0f);
glColor3f(  1.0f,  0.0f, 0.0f);
glVertex3f( 1.0f,  1.0f, 0.0f);

glEnd();
glFlush();
}
void Resize(int w, int h) {
glViewport(0, 0, w, h);
}
void Shutdown() {
shutdown = 1;   
}
#endif

我用:

g++ -g -Wall -o _build/main main.cpp -I/opt/x11/include  -L/usr/x11/lib -lGL -lX11

OS:

Linux kali 5.9.0-kali4-amd64 #1 SMP Debian 5.9.11-1kali1 (2020-12-01) x86_64 GNU/Linux

Answer 1

您的代码将不呈现三角形，但将在您的glBegin/glEnd结构上生成GL_INVALID_OPERATION。原因如下:

int context_attribs[] = {
GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
GLX_CONTEXT_MINOR_VERSION_ARB, 2,
GLX_CONTEXT_FLAGS_ARB, GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
None
};

根据GLX_ARB_create_contextGLX扩展规范(强调我的):

如果请求3.2或更高版本，返回的上下文可以实现以下任何版本:

• 请求的配置文件
• 请求的配置文件

，通过您提交的GLX_CONTEXT_PROFILE_MASK_ARB属性请求配置文件，因此将应用默认值:

GLX_CONTEXT_PROFILE_MASK_ARB默认值为GLX_CONTEXT_CORE_PROFILE_BIT_ARB。所有OpenGL 3.2实现都是需要实现的核心配置文件，但实现的兼容性配置文件是可选的

glBegin/glEnd绘图模式、固定函数管道、矩阵堆栈等遗留特性均被删除从OpenGL的核心配置文件

要运行此代码，您有3个选项:

1. 请求GL版本<= 2.1。这将为您提供与遗留实现的最大兼容性。它基本上会产生相同的结果，如果你根本不使用GLX_ARB_create_context扩展。
2. 明确请求GL 3.2与GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB(并删除GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB)。这取决于你的实现是否支持。
3. 保持GL上下文为3.2核心，只需编写核心配置文件兼容的代码。

选项3实际上是2021年唯一有意义的选项。但是，它将需要比当前更多的设置代码。你必须编写自己的着色器，并为顶点属性和相应的数据数组设置VAO和VBO。

注意选项3也会打断

与预安装的GL/GL .h和GL/glx.h.

是你的前提的一部分。您至少需要删除gl.h头文件，而使用GL加载器生成的头文件。