Hi there,
I have the following code to run some simple OpenGL applications from an ARM Cortex A9 running Ubuntu 12.04 LTS.
When I compile and run the code I get the following GLX error:
X Error of failed request: BadRequest (Invalid request code or no such operation)
Major opcode of failed request: 153 (GLX)
Minor opcode of failed request: 34 ()
Serial number of failed request: 36
Current serial number in output stream: 35
Running this with debug symbols on only adds the following line [Inferior 1 (process 1569) exited with code 01]
which is not really helpful.
Code for Main loop:
#include "CubeTexture.h"
#ifdef _WIN32
#include <BasicEngine\Engine.h>
#elif __linux__
#include "../BasicEngine/Engine.h"
#include <pthread.h>
#endif
using namespace BasicEngine;
#ifdef __linux__
void junk() {
int i;
i = pthread_getconcurrency();
}
#endif
int main(int argc, char **argv)
{
Engine* engine = new Engine();
engine->Init();
engine->GetShader_Manager()->CreateProgram("cubeShader", "./Shaders/Cube_Vertex_Shader.glsl", "./Shaders/Cube_Fragment_Shader.glsl");
CubeTexture* cube = new CubeTexture();
int program = engine->GetShader_Manager()->GetShader("cubeShader");
if (program != 0)
{
cube->SetProgram(program);
cube->Create();
}
else
{
std::cout << "invalid program..."; std::cin.get();
}
unsigned int texture = engine->GetTexture_Loader()->LoadTexture("./Textures/Crate.bmp", 256, 256);
cube->SetTexture("Create", texture);
engine->GetModels_Manager()->SetModel("cube", cube);
engine->Run();
delete engine;
return (0);
}
Code to initialise GLUT and X Windows environment
#include "../Init/Init_GLUT.h"
using namespace BasicEngine;
using namespace Core::Init;
Core::IListener* Init_GLUT::listener = NULL;
Core::WindowInfo Init_GLUT::windowInformation;
#ifdef __linux__
Display *dpy;
Window root;
GLint att[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None };
XVisualInfo *vi;
Colormap cmap;
XSetWindowAttributes swa;
Window win;
GLXContext glc;
XWindowAttributes gwa;
XEvent xev;
void Init_GLUT::linuxinit()
{
std::cout << "Linux detected" << std::endl;
dpy = XOpenDisplay(NULL);
if (dpy == NULL)
{
std::cout << "
cannont connect to X server
" << std::endl;
exit(0);
}
root = DefaultRootWindow(dpy);
vi = glXChooseVisual(dpy, 0, att);
if (vi == NULL)
{
std::cout << "
no appropriate visual found
" << std::endl;
exit(0);
}
else
{
std::cout << "
visual %p selected
" << (void*)vi->visualid << std::endl; //%p creates a hexadecimal output like in glxinfo
}
cmap = XCreateColormap(dpy, root, vi->visual, AllocNone);
swa.colormap = cmap;
swa.event_mask = ExposureMask | KeyPressMask;
std::cout << "end of Linux compiler directives" << std::endl;
}
#endif
void Init_GLUT::init(const Core::WindowInfo& windowInfo,
const Core::ContextInfo& contextInfo,
const Core::FramebufferInfo& framebufferInfo)
{
windowInformation = windowInfo;
//i need some fake things here
int fakeargc = 1;
char* fakeargv[] = { "fake", NULL };
glutInit(&fakeargc, fakeargv);
if (contextInfo.core)
{
glutInitContextVersion(contextInfo.major_version,
contextInfo.minor_version);
glutInitContextProfile(GLUT_CORE_PROFILE);
}
else
{
//doesn't matter in compatibility mode
glutInitContextProfile(GLUT_COMPATIBILITY_PROFILE);
}
//old functions from main.cpp now using info from the structures
glutInitDisplayMode(framebufferInfo.flags);
glutInitWindowPosition(windowInfo.position_x, windowInfo.position_y);
glutInitWindowSize(windowInfo.width, windowInfo.height);
glutCreateWindow(windowInfo.name.c_str());
std::cout << "GLUT:initialised" << std::endl;
#ifdef _WIN32
//Lets add some debug capability
glEnable(GL_DEBUG_OUTPUT);
#endif
Core::Init::Init_GLEW::Init();
#ifdef _WIN32
glDebugMessageCallback(DebugOutput::myCallback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, TRUE);
#endif
//these call backs are used for rendering
glutIdleFunc(idleCallback);
glutCloseFunc(closeCallback);
glutDisplayFunc(displayCallback);
glutReshapeFunc(reshapeCallback);
//init GLEW (can be called in main.cpp)
//clean up
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS);
//our method to display some info. Needs contextInfo and windowinfo
printOpenGLInfo(windowInfo, contextInfo);
}
//starts the rendering loop
void Init_GLUT::run()
{
std::cout << "GLUT: Start Running" << std::endl;
glutMainLoop();
}
void Init_GLUT::close()
{
std::cout << "GLUT: Finished" << std::endl;
glutLeaveMainLoop;
}
void Init_GLUT::idleCallback(void)
{
//do nothing, just redisplay
glutPostRedisplay();
}
void Init_GLUT::displayCallback()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearColor(0.0, 0.0, 0.0, 1);
glutSwapBuffers;
if (listener)
{
listener->notifyBeginFrame();
listener->notifyDisplayFrame();
glutSwapBuffers();
listener->notifyEndFrame();
}
}
void Init_GLUT::reshapeCallback(int width, int height)
{
if (windowInformation.isReshapable == true)
{
if (listener)
{
listener->notifyReshape(width, height, windowInformation.width, windowInformation.height);
}
windowInformation.width = width;
windowInformation.height = height;
}
}
void Init_GLUT::closeCallback()
{
close();
}
void Init_GLUT::enterFullscreen()
{
glutFullScreen();
}
void Init_GLUT::exitFullscreen()
{
glutLeaveFullScreen();
}
void Init_GLUT::setListener(Core::IListener* iListener)
{
listener = iListener;
}
void Init_GLUT::printOpenGLInfo(const Core::WindowInfo& windowInfo,
const Core::ContextInfo& contextInfo)
{
const unsigned char* renderer = glGetString(GL_RENDERER);
const unsigned char* vendor = glGetString(GL_VENDOR);
const unsigned char* version = glGetString(GL_VERSION);
std::cout << "*******************************************************************************" << std::endl;
std::cout << "GLUT: Vendor : " << vendor << std::endl;
std::cout << "GLUT: Renderer : " << renderer << std::endl;
std::cout << "GLUT: OpenGl version: " << version << std::endl;
std::cout << "GLUT: Initial window is '" << windowInfo.name << "', with dimensions (" << windowInfo.width
<< "X" << windowInfo.height;
std::cout << ") starts at (" << windowInfo.position_x << "X" << windowInfo.position_y;
std::cout << ") and " << ((windowInfo.isReshapable) ? "is" : "is not ") << " redimensionable" << std::endl;
std::cout << "GLUT: Initial Framebuffer contains double buffers for" << std::endl;
std::cout << "GLUT: OpenGL context is " << contextInfo.major_version << "." << contextInfo.minor_version;
std::cout << " and profile is " << ((contextInfo.core) ? "core" : "compatibility") << std::endl;
std::cout << "*****************************************************************" << std::endl;
}
Does anybody know what is causing the error? Or indeed what BadRequest, Major Opcode 153 (GLX) actually refers to?
Cheers