// Dialog procedure.
BOOL APIENTRY AboutDlgProc(HWND hDlg, UINT message, UINT wParam, LONG lParam)
{
switch (message)
{
// Initialize the dialog box
case WM_INITDIALOG:
{
int i;
GLenum glError;
// glGetString demo
SetDlgItemText(hDlg, IDC_OPENGL_VENDOR, (LPCSTR)glGetString(GL_VENDOR));
SetDlgItemText(hDlg, IDC_OPENGL_RENDERER, (LPCSTR)glGetString(GL_RENDERER));
SetDlgItemText(hDlg, IDC_OPENGL_VERSION, (LPCSTR)glGetString(GL_VERSION));
SetDlgItemText(hDlg, IDC_OPENGL_EXTENSIONS, (LPCSTR)glGetString(GL_EXTENSIONS));
// gluGetString demo
SetDlgItemText(hDlg, IDC_GLU_VERSION, (LPCSTR)gluGetString(GLU_VERSION));
SetDlgItemText(hDlg, IDC_GLU_EXTENSIONS, (LPCSTR)gluGetString(GLU_EXTENSIONS));
// Display any recent error messages
i = 0;
do {
glError = glGetError();
SetDlgItemText(hDlg, IDC_ERROR1 + i, (LPCSTR)gluErrorString(glError));
i++;
} while (i < 6 && glError != GL_NO_ERROR);
return (TRUE);
}
break;
// Process command messages
case WM_COMMAND:
{
// Validate and Make the changes
if (LOWORD(wParam) == IDOK)
EndDialog(hDlg, TRUE);
}
break;
// Closed from sysbox
case WM_CLOSE:
EndDialog(hDlg, TRUE);
break;
}
return FALSE;
}
// Fonction principale
int main(int argc, char **argv)
{
// Initialisation de la GLUT
glutInit(&argc, argv);
// Choix de double buffer
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
// Position de la fenêtre
glutInitWindowPosition (fenetreX, fenetreY);
// Taille de la fenêtre
glutInitWindowSize (fenetreLargeur,fenetreHauteur);
// Création de la fenêtre GLUT
glutCreateWindow (argv[0]);
// informations sur les versions OpenGL et GLU utilisées
printf("Version OpenGL, OS:%s\n",glGetString(GL_VERSION));
printf("Vendeur:%s\n",glGetString(GL_VENDOR));
printf("Renderer:%s\n",glGetString(GL_RENDERER));
printf("Version GLU:%s\n",gluGetString(GLU_VERSION));
printf("Extensions GLU:%s\n\n",gluGetString(GLU_EXTENSIONS));
// Initialisation
init();
// Fonction callback d'affichage
glutDisplayFunc(display);
// Fonction callback de redimensionnement.
glutReshapeFunc(reshape);
// Fonction callback d'animation
glutIdleFunc(cameraAutoRotation);
// On key pressed
//glutKeyboardFunc(keyPressed);
//glutSpecialFunc(keyPressed);
// Initialisation du menu et de ses sous-menus.
initMenu();
// Lancement de la boucle
glutMainLoop();
// Fin de programme
return 0;
}
InfoView::InfoView()
:
BGroupView(B_TRANSLATE("Information"), B_HORIZONTAL)
{
BStringView* rendererView = new BStringView(NULL,
(const char*)glGetString(GL_RENDERER));
rendererView->SetExplicitAlignment(kLabelAlignment);
rendererView->SetFont(be_bold_font);
BStringView* vendorNameView = new BStringView(NULL,
(const char*)glGetString(GL_VENDOR));
vendorNameView->SetExplicitAlignment(kLabelAlignment);
BStringView* glVersionView = new BStringView(NULL,
(const char*)glGetString(GL_VERSION));
glVersionView->SetExplicitAlignment(kLabelAlignment);
BString apiString("GLU ");
apiString << (const char*)gluGetString(GLU_VERSION);
apiString << ", GLUT ";
apiString << (int32)GLUT_API_VERSION;
BStringView* apiVersionView = new BStringView(NULL, apiString.String());
apiVersionView->SetExplicitAlignment(kLabelAlignment);
BLayoutBuilder::Group<>(this)
.AddGroup(B_VERTICAL, 0)
.Add(rendererView)
.Add(vendorNameView)
.Add(glVersionView)
.Add(apiVersionView)
.End();
}
static int tolua_glu_gluGetString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isnumber(tolua_S,1,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
int name = (( int) tolua_tonumber(tolua_S,1,0));
{
unsigned const char* tolua_ret = ( unsigned const char*) gluGetString(name);
tolua_pushstring(tolua_S,(const char*)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'gluGetString'.",&tolua_err);
return 0;
#endif
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(300, 300);
glutInitWindowPosition(100, 100);
glutCreateWindow("OpenGL Version");
#pragma region show version string
const GLubyte* name = glGetString(GL_VENDOR); //返回负责当前OpenGL实现厂商的名字
const GLubyte* biaoshifu = glGetString(GL_RENDERER); //返回一个渲染器标识符，通常是个硬件平台
const GLubyte* OpenGLVersion = glGetString(GL_VERSION); //返回当前OpenGL实现的版本号
const GLubyte* gluVersion = gluGetString(GLU_VERSION); //返回当前GLU工具库版本
printf("OpenGL实现厂商的名字：%s\n", name);
printf("渲染器标识符：%s\n", biaoshifu);
printf("OpenGL实现的版本号：%s\n", OpenGLVersion);
printf("OGLU工具库版本：%s\n", gluVersion);
#pragma endregion show version string
glutDisplayFunc(renderScene);
glutReshapeFunc(changeSize);
glutMainLoop();
return 0;
}
int main()
{
if (execute) {
// This needs an active GL context, so not executed, but serves
// as a link test.
(void) glGetString(GL_VERSION);
(void) gluGetString(GLU_VERSION);
}
std::cout << "version=" <<
#if defined GL_VERSION_2_1
"2.1"
#elif defined GL_VERSION_2_0
"2.0"
#elif defined GL_VERSION_1_5
"1.5"
#elif defined GL_VERSION_1_4
"1.4"
#elif defined GL_VERSION_1_3
"1.3"
#elif defined GL_VERSION_1_2
"1.2"
#elif defined GL_VERSION_1_1
"1.1"
#elif defined GL_VERSION_1_0
"1.0"
#else
"unknown"
#endif
<< std::endl;
return 0;
}
std::string OGLInspector::GetGluVersion()
{
#ifndef GLU_VERSION_1_1
return "1.0";
#else
return (char*)(gluGetString(GLU_VERSION));
#endif
}
std::string OGLInspector::GetGluExtensions()
{
#ifndef GLU_VERSION_1_1
return "";
#else
return (char*)(gluGetString(GLU_EXTENSIONS));
#endif
}
static void hugsprim_gluGetString_0(HugsStackPtr hugs_root)
{
HsWord32 arg1;
HsPtr res1;
arg1 = hugs->getWord32();
res1 = gluGetString(arg1);
hugs->putPtr(res1);
hugs->returnIO(hugs_root,1);
}
void ShaderManager::checkUniformError( void )
{
GLenum error = glGetError();
if (error != GL_NO_ERROR)
{
Log::ErrorFmt(getClassName(), "Uniform Error, #%d %s", error, gluGetString(error));
}
}
static void screenInfo( Display *dpy, int scrnum, QString &infotext )
{
const char *serverVendor = glXQueryServerString( dpy, scrnum, GLX_VENDOR );
const char *serverVersion = glXQueryServerString( dpy, scrnum, GLX_VERSION );
const char *serverExtensions = glXQueryServerString( dpy, scrnum, GLX_EXTENSIONS );
const char *clientVendor = glXGetClientString( dpy, GLX_VENDOR );
const char *clientVersion = glXGetClientString( dpy, GLX_VERSION );
const char *clientExtensions = glXGetClientString( dpy, GLX_EXTENSIONS );
const char *glxExtensions = glXQueryExtensionsString( dpy, scrnum );
const char *glVendor = (const char *) glGetString( GL_VENDOR );
const char *glRenderer = (const char *) glGetString( GL_RENDERER );
const char *glVersion = (const char *) glGetString( GL_VERSION );
const char *glExtensions = (const char *) glGetString( GL_EXTENSIONS );
const char *gluVersion = (const char *) gluGetString( (GLenum) GLU_VERSION );
const char *gluExtensions = (const char *) gluGetString( (GLenum) GLU_EXTENSIONS );
infotext.sprintf( "%sServer GLX vendor string: %s\n", infotext.ascii(), serverVendor );
infotext.sprintf( "%sServer GLX version string: %s\n", infotext.ascii(), serverVersion );
infotext.sprintf( "%sServer GLX extensions:\n", infotext.ascii() );
infotext += QString( serverExtensions ).replace( ' ', '\n' ) + "\n\n";
infotext.sprintf( "%sClient GLX vendor string: %s\n", infotext.ascii(), clientVendor );
infotext.sprintf( "%sClient GLX version string: %s\n", infotext.ascii(), clientVersion );
infotext.sprintf( "%sClient GLX extensions:\n", infotext.ascii() );
infotext += QString( clientExtensions ).replace( ' ', '\n' ) + "\n\n";
infotext.sprintf( "%sGLX extensions:\n", infotext.ascii() );
infotext += QString( glxExtensions ).replace( ' ', '\n' ) + "\n\n";
infotext.sprintf( "%sOpenGL vendor string: %s\n", infotext.ascii(), glVendor );
infotext.sprintf( "%sOpenGL renderer string: %s\n", infotext.ascii(), glRenderer );
infotext.sprintf( "%sOpenGL version string: %s\n", infotext.ascii(), glVersion );
infotext.sprintf( "%sOpenGL extensions:\n", infotext.ascii() );
infotext += QString( glExtensions ).replace( ' ', '\n' ) + "\n\n";
infotext.sprintf( "%sGLU version: %s\n", infotext.ascii(), gluVersion );
infotext.sprintf( "%sGLU extensions:\n", infotext.ascii() );
infotext += QString( gluExtensions ).replace( ' ', '\n' ) + "\n\n";
}
void CoreInit(void (GLUTCALLBACK *drawFunc)(void),int argc,char **argv)
{
glutInit(&argc, (char**)argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH);
glutInitWindowSize(SCREEN_SIZE_X, SCREEN_SIZE_Y);
glutInitWindowPosition(0, 0);
glutCreateWindow("Title");
glutDisplayFunc(drawFunc);
glutIdleFunc(drawFunc);
glutReshapeFunc(&CoreReshape);
glutSpecialFunc(&CorekeyDown1Static);
glutSpecialUpFunc(&CorekeyUp1Static);
glutKeyboardFunc(&CorekeyDown2Static);
glutKeyboardUpFunc(&CorekeyUp2Static);
glutMotionFunc(&CoreMouseMotionStatic);
glutPassiveMotionFunc(&CoreMouseMotionStatic);
glutMouseFunc (&CoreMouseButtonStatic);
glewInit();
std::cout << "GL_VERSION: " << glGetString(GL_VERSION) << std::endl; //std::cout << "GL_EXTENSIONS: " << glGetString(GL_EXTENSIONS) << std::endl;
std::cout << "GL_RENDERER: " << glGetString(GL_RENDERER) << std::endl;
std::cout << "GL_VENDOR: " << glGetString(GL_VENDOR) << std::endl;
std::cout << "GLU_VERSION: " << gluGetString(GLU_VERSION) << std::endl; //std::cout << "GLU_EXTENSIONS: " << gluGetString(GLU_EXTENSIONS) << std::endl;
std::cout << "GLUT_API_VERSION: " << GLUT_API_VERSION << std::endl;
int res[16];
#ifndef MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS
#define MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS 0x8E81
#endif
#ifndef MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS
#define MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS 0x8E82
#endif
glGetIntegerv(MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS,res);
printf("MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS %d\n",res[0]);
glGetIntegerv(MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS,res);
printf("MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS %d\n",res[0]);
wglSwapIntervalEXT(0);
//glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, GL_FALSE);CHECK_GL_ERROR();
//glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, GL_FALSE);CHECK_GL_ERROR();
glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);CHECK_GL_ERROR();
glClearDepth(1.0); // Enables Clearing Of The Depth Buffer
glDepthFunc(GL_LESS); // The Type Of Depth Test To Do
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glShadeModel(GL_SMOOTH); // Enables Smooth Color Shading
glEnable(GL_CULL_FACE);
glCullFace (GL_FRONT);
}
// set the error message
void VRML_LAYER::SetGLError( GLenum errorID )
{
error = "";
error = (const char*)gluGetString( errorID );
if( error.empty() )
{
std::ostringstream ostr;
ostr << "Unknown OpenGL error: " << errorID;
error = ostr.str();
}
}
void DVRClipper::initialize(DVRVolume *volume)
{
if(volume == NULL)
return;
// get clip objects
DVRClipObjectsPtr clipObjects = DVRVOLUME_PARAMETER(volume,
DVRClipObjects);
if(clipObjects == NullFC)
return;
if(!hasTesselatorSupport)
{
// check for glu tesselator support
hasTesselatorSupport = (atof((char*)gluGetString(GLU_VERSION)) >= 1.2);
if(!hasTesselatorSupport)
return;
}
if(myTess == NULL)
{
myTess = gluNewTess();
// registering callback functions for glu tesselator...
gluTessCallback(myTess,
GLU_TESS_COMBINE_DATA,
(GLvoid (CALLBACK *)()) vertexCombineCallback);
gluTessCallback(myTess,
GLU_TESS_VERTEX_DATA,
(GLvoid (CALLBACK *)()) vertexCallback);
gluTessCallback(myTess,
GLU_TESS_BEGIN_DATA,
(GLvoid (CALLBACK *)()) beginCallback);
gluTessCallback(myTess,
GLU_TESS_END_DATA,
(GLvoid (CALLBACK *)()) endCallback);
gluTessCallback(myTess,
GLU_TESS_ERROR,
(GLvoid (CALLBACK *)()) errorCallback);
}
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_MULTISAMPLE);
glutInitWindowPosition(520, 10);
glutInitWindowSize(WIDTH, HEIGHT);
window1 = glutCreateWindow("shadow sample");
GLenum err = glewInit();
if(err != GLEW_OK){
std::cout << "fail" << std::endl;
return -1;
}
//multisample, is this realized by the fixed pipeline? I need to
//rewrite it in a shader with fbo maybe.
GLint bufs, samples;
glGetIntegerv(GL_SAMPLE_BUFFERS, &bufs);
glGetIntegerv(GL_SAMPLES, &samples);
glEnable(GL_MULTISAMPLE);
//show some info
const GLubyte *name = glGetString(GL_VENDOR);
const GLubyte *renderer = glGetString(GL_RENDERER);
const GLubyte *version = glGetString(GL_VERSION);
const GLubyte *gluversion = gluGetString(GLU_VERSION);
std::cout << "++++++++++++++++++++++++++++" << std::endl
<< "+ GL_VENDOR: " << name << std::endl
<< "+ GL_RENDERER: " << renderer << std::endl
<< "+ GL_VERSION: " << version << std::endl
<< "+ GLU_VERSION: " << gluversion << std::endl
<< "++++++++++++++++++++++++++++" << std::endl;
init();
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(keyboarddown);
glutKeyboardUpFunc(keyboardup);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
//openwin2();
glutMainLoop();
glDeleteVertexArrays(1, &box_vao);
glDeleteBuffers(1, &vertexID);
return 0;
}
static struct once { once() {
// Initialize GLEW
glewExperimental= GL_TRUE;
GLenum err = glewInit ();
if (GLEW_OK != err)
{
// Problem: glewInit failed, something is seriously wrong.
std::cerr << "<gate/render/window.cpp> says: Error: " << glewGetErrorString (err) << std::endl;
std::exit(1);
}
// Print some infos about user's OpenGL implementation
if(0)
{
std::cout << "OpenGL Version String: " << glGetString (GL_VERSION) << std::endl;
std::cout << "GLU Version String: " << gluGetString (GLU_VERSION) << std::endl;
std::cout << "GLEW Version String: " << glewGetString (GLEW_VERSION) <<std::endl;
}
}} _2;
int main(int argc, char** argv)
{
// 返回负责当前OpenGL实现厂商的名字
const GLubyte* name = glGetString(GL_VENDOR);
// 返回一个渲染器标识符，通常是个硬件平台
const GLubyte* renderID = glGetString(GL_RENDERER);
// 返回当前OpenGL实现的版本号
const GLubyte* OpenGLVersion = glGetString(GL_VERSION);
// 返回当前GLU工具库版本
const GLubyte* gluVersion = gluGetString(GLU_VERSION);
printf("OpenGL实现厂商的名字：%s\n", name);
printf("渲染器标识符：%s\n", renderID);
printf("OpenGL实现的版本号：%s\n", OpenGLVersion);
printf("GLU工具库版本：%s\n", gluVersion);
return 0;
}
/* GetString (name) -> string */
static int luaglu_get_string(lua_State *L)
{
GLenum e;
const GLubyte *str;
/* test argument type */
if(!lua_isstring(L, 1))
luaL_error(L, "incorrect argument to function 'glu.GetString'");
/* get string parameter */
e = luaglu_get_gl_enum(L, 1);
/* test argument */
if(e == LUAGL_ENUM_ERROR)
luaL_error(L, "incorrect string argument to function 'glu.GetString'");
/* call opengl function */
str = gluGetString(e);
lua_pushstring(L, (const char*)str);
return 1;
}
void showSystemInfo_plat(){
//opengl version query
//see: http://www.opengl.org/wiki/GlGetString
const GLubyte* s_gl_vendor = glGetString(GL_VENDOR);
const GLubyte* s_gl_renderer = glGetString(GL_RENDERER);
const GLubyte* s_gl_version =glGetString(GL_VERSION);
const GLubyte* s_glu_version= gluGetString(GLU_VERSION);
cout<<endl;
cout<<"OpenGL vendor: "<<s_gl_vendor<<endl;
cout<<"GPU:"<<s_gl_renderer<<endl;
cout<<"OpenGL version: "<<s_gl_version<<endl;
cout<<"GLU version: "<<s_glu_version<<endl;
//see if support opengl 2.0
if (glewIsSupported("GL_VERSION_2_0"))
cout<<"support openGL 2.0!"<<endl;
else {
cout<<"not support openGL 2.0!"<<endl;
assert(false);
}
//GLSL version
const GLubyte* s= glGetString(GL_SHADING_LANGUAGE_VERSION);
cout<<s<<endl;
cout<<endl;
}
/* GetString (name) -> string */
static int luaglu_get_string(lua_State *L)
{
lua_pushstring(L, (char*)gluGetString(luaglu_get_gl_enum(L, 1)));
return 1;
}
static PyObject* opengl_init( PyObject* self, PyObject* args )
{
GL_ERROR_CHECK("top of opengl_init");
printf( " vendor : %s\n", glGetString( GL_VENDOR ) );
printf( " renderer : %s\n", glGetString( GL_RENDERER ) );
printf( " version : %s\n", glGetString( GL_VERSION ) );
printf( "glu version : %s\n", gluGetString( GLU_VERSION ) );
/*printf( "extensions : %s\n", glGetString( GL_EXTENSIONS ) );*/
glewExperimental=GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
printf("Error: %s\n", glewGetErrorString(err));
}
printf("Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
if (glewIsSupported("GLX_SGI_swap_control"))
{
/* It is safe to use the ARB_vertex_program extension here. */
printf("GLX_SGI_swap_control supported!\n");
//glXSwapIntervalSGI(1);
}
else
{
printf("No GLX_SGI_swap_control support.\n");
}
if (glewIsSupported("GLX_SGI_video_sync"))
{
/* It is safe to use the ARB_vertex_program extension here. */
printf("GLX_SGI_video_sync supported!\n");
//glXSwapIntervalSGI(1);
int retraceCount;
glXGetVideoSyncSGI(&retraceCount);
glXWaitVideoSyncSGI(2, (retraceCount+1)%2, &retraceCount);
}
else
{
printf("GLX_SGI_video_sync support.\n");
int c;
//__glewXWaitVideoSyncSGI(5,0,&c);
}
glEnable( GL_VERTEX_ARRAY );
/* on mac, we expect that to fail; must be enabled as
client state instead, */
if(glGetError() != GL_NO_ERROR) {
glEnableClientState( GL_VERTEX_ARRAY );
GL_ERROR_CHECK( "enable client gl_vertex_array" );
}
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_ALWAYS );
glClearDepth( 0.0 );
GL_ERROR_CHECK( "end of opengl_init" );
//glEnable( GL_POLYGON_SMOOTH );
Py_INCREF( Py_None );
return Py_None;
}
/******************************************************************************
*############################################################################*
*# Screen functions #*
*############################################################################*
******************************************************************************/
void
openglInit()
{
/*setting up OpenGL*/
screen_w = 10;
screen_h = 10;
global_screenratio = 1.0;
glViewport(0, 0, 10, 10);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
vp_wrel = vp_hrel = FALSE;
vp_top = vp_left = 0;
vp_width = vp_height = 10;
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
wireframe2d = FALSE;
wireframe3d = FALSE;
shading = GL_SMOOTH;
lighting = TRUE;
texture2d = TRUE;
texture3d = TRUE;
glFrontFace(GL_CCW);
glCullFace(GL_BACK);
glDepthFunc(GL_LEQUAL);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
global_forceblend = FALSE;
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
glHint(GL_FOG_HINT, GL_FASTEST);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, TRUE);
curcount = 0;
count = 0;
fog = FALSE;
fogdensity = 0.0;
fogcolor[0] = 0.5;
fogcolor[1] = 0.5;
fogcolor[2] = 0.5;
fogcolor[3] = 1.0;
/*core declaration*/
MOD_ID = coreDeclareModule("opengl", NULL, NULL, shellCallback, NULL, NULL, NULL);
FUNC_WIREFRAME = coreDeclareShellFunction(MOD_ID, "wireframe", VAR_VOID, 2, VAR_INT, VAR_INT);
FUNC_FOG = coreDeclareShellFunction(MOD_ID, "fog", VAR_VOID, 1, VAR_INT);
FUNC_LIGHTING = coreDeclareShellFunction(MOD_ID, "lighting", VAR_VOID, 2, VAR_INT, VAR_INT);
FUNC_TEXTURE = coreDeclareShellFunction(MOD_ID, "texture", VAR_VOID, 2, VAR_INT, VAR_INT);
FUNC_COUNT = coreDeclareShellFunction(MOD_ID, "count", VAR_INT, 0);
/*OpenGL info*/
shellPrintf(LEVEL_INFO, " -> OpenGL version: %s", (const char*)glGetString(GL_VERSION));
shellPrintf(LEVEL_INFO, " -> OpenGL vendor: %s", (const char*)glGetString(GL_VENDOR));
shellPrintf(LEVEL_INFO, " -> OpenGL renderer: %s", (const char*)glGetString(GL_RENDERER));
shellPrintf(LEVEL_DEBUG, " -> OpenGL extensions: %s", (const char*)glGetString(GL_EXTENSIONS));
/*GLU info*/
shellPrintf(LEVEL_INFO, " -> GLU version: %s", (const char*)gluGetString(GLU_VERSION));
shellPrintf(LEVEL_DEBUG, " -> GLU extensions: %s", (const char*)gluGetString(GLU_EXTENSIONS));
}
static void
print_screen_info(Display *dpy, int scrnum, Bool allowDirect, GLboolean limits)
{
Window win;
int attribSingle[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
None };
int attribDouble[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER,
None };
XSetWindowAttributes attr;
unsigned long mask;
Window root;
GLXContext ctx;
XVisualInfo *visinfo;
int width = 100, height = 100;
root = RootWindow(dpy, scrnum);
visinfo = glXChooseVisual(dpy, scrnum, attribSingle);
if (!visinfo) {
visinfo = glXChooseVisual(dpy, scrnum, attribDouble);
if (!visinfo) {
fprintf(stderr, "Error: couldn't find RGB GLX visual\n");
return;
}
}
attr.background_pixel = 0;
attr.border_pixel = 0;
attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
attr.event_mask = StructureNotifyMask | ExposureMask;
mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
win = XCreateWindow(dpy, root, 0, 0, width, height,
0, visinfo->depth, InputOutput,
visinfo->visual, mask, &attr);
ctx = glXCreateContext( dpy, visinfo, NULL, allowDirect );
if (!ctx) {
fprintf(stderr, "Error: glXCreateContext failed\n");
XDestroyWindow(dpy, win);
return;
}
if (glXMakeCurrent(dpy, win, ctx)) {
const char *serverVendor = glXQueryServerString(dpy, scrnum, GLX_VENDOR);
const char *serverVersion = glXQueryServerString(dpy, scrnum, GLX_VERSION);
const char *serverExtensions = glXQueryServerString(dpy, scrnum, GLX_EXTENSIONS);
const char *clientVendor = glXGetClientString(dpy, GLX_VENDOR);
const char *clientVersion = glXGetClientString(dpy, GLX_VERSION);
const char *clientExtensions = glXGetClientString(dpy, GLX_EXTENSIONS);
const char *glxExtensions = glXQueryExtensionsString(dpy, scrnum);
const char *glVendor = (const char *) glGetString(GL_VENDOR);
const char *glRenderer = (const char *) glGetString(GL_RENDERER);
const char *glVersion = (const char *) glGetString(GL_VERSION);
const char *glExtensions = (const char *) glGetString(GL_EXTENSIONS);
int glxVersionMajor;
int glxVersionMinor;
char *displayName = NULL;
char *colon = NULL, *period = NULL;
#ifdef DO_GLU
const char *gluVersion = (const char *) gluGetString(GLU_VERSION);
const char *gluExtensions = (const char *) gluGetString(GLU_EXTENSIONS);
#endif
if (! glXQueryVersion( dpy, & glxVersionMajor, & glxVersionMinor )) {
fprintf(stderr, "Error: glXQueryVersion failed\n");
exit(1);
}
/* Strip the screen number from the display name, if present. */
if (!(displayName = (char *) malloc(strlen(DisplayString(dpy)) + 1))) {
fprintf(stderr, "Error: malloc() failed\n");
exit(1);
}
strcpy(displayName, DisplayString(dpy));
colon = strrchr(displayName, ':');
if (colon) {
period = strchr(colon, '.');
if (period)
*period = '\0';
}
printf("display: %s screen: %d\n", displayName, scrnum);
free(displayName);
printf("direct rendering: %s\n", glXIsDirect(dpy, ctx) ? "Yes" : "No");
printf("server glx vendor string: %s\n", serverVendor);
printf("server glx version string: %s\n", serverVersion);
printf("server glx extensions:\n");
print_extension_list(serverExtensions);
printf("client glx vendor string: %s\n", clientVendor);
printf("client glx version string: %s\n", clientVersion);
printf("client glx extensions:\n");
print_extension_list(clientExtensions);
printf("GLX version: %u.%u\n", glxVersionMajor, glxVersionMinor);
printf("GLX extensions:\n");
print_extension_list(glxExtensions);
printf("OpenGL vendor string: %s\n", glVendor);
printf("OpenGL renderer string: %s\n", glRenderer);
printf("OpenGL version string: %s\n", glVersion);
printf("OpenGL extensions:\n");
print_extension_list(glExtensions);
if (limits)
print_limits();
#ifdef DO_GLU
printf("glu version: %s\n", gluVersion);
printf("glu extensions:\n");
print_extension_list(gluExtensions);
#endif
}
else {
fprintf(stderr, "Error: glXMakeCurrent failed\n");
}
glXDestroyContext(dpy, ctx);
XDestroyWindow(dpy, win);
}
void SettingsDialog::setup()
{
FXVerticalFrame* vframe;
FXHorizontalFrame* hframe;
FXMatrix* matrix;
FXLabel* label;
FXFontDesc fontdescription = getApp()->getNormalFont()->getFontDesc();
fontdescription.weight = FXFont::DemiBold;
thickfont=new FXFont(getApp(), fontdescription);
thickfont->create();
FXGLVisual* glvisual = static_cast<FXGLVisual*>(canvas->getVisual());
canvas->makeCurrent();
setTitle(tr("OpenGL Information"));
hframe = new FXHorizontalFrame(this, LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH);
new FXButton(hframe, tr("Close"), nullptr, this, ID_ACCEPT,FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|BUTTON_DEFAULT|BUTTON_INITIAL,0,0,0,0,20,20,2,2);
new FXButton(hframe, tr("Save"), nullptr, this, ID_SAVE,FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT,0,0,0,0,20,20,2,2);
FXTabBook* tabbook = new FXTabBook(this,nullptr,0,LAYOUT_FILL_X|LAYOUT_FILL_Y,0,0,0,0);
new FXTabItem(tabbook, tr(" Display Mode "));
matrix = new FXMatrix(tabbook,2,MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED|FRAME_THICK);
label = new FXLabel(matrix, tr("Hardware-accelerated:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, tr(PRINT_YESNO(glvisual->isAccelerated())), nullptr, LABEL_NORMAL);
label = new FXLabel(matrix, tr("Double Buffering:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, tr(PRINT_YESNO(glvisual->isDoubleBuffer())), nullptr, LABEL_NORMAL);
label = new FXLabel(matrix, tr("Stereo View:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, tr(PRINT_YESNO(glvisual->isStereo())), nullptr, LABEL_NORMAL);
label = new FXLabel(matrix, tr("Buffer-swap by copy:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, tr(PRINT_YESNO(glvisual->isBufferSwapCopy())), nullptr, LABEL_NORMAL);
label = new FXLabel(matrix, tr("Color Depth:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%d",glvisual->getActualRedSize()+glvisual->getActualGreenSize()+glvisual->getActualBlueSize()+glvisual->getActualAlphaSize()),NULL,LABEL_NORMAL);
label = new FXLabel(matrix, tr("Depth Buffer Size:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%d",glvisual->getActualDepthSize()), nullptr, LABEL_NORMAL);
label = new FXLabel(matrix, tr("Stencil Buffer Size:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%d",glvisual->getActualStencilSize()), nullptr, LABEL_NORMAL);
label = new FXLabel(matrix, tr("RGBA:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix,FXString::value("%d-%d-%d-%d",glvisual->getActualRedSize(),glvisual->getActualGreenSize(),glvisual->getActualBlueSize(),glvisual->getActualAlphaSize()),NULL,LABEL_NORMAL);
label = new FXLabel(matrix, tr("Accum RGBA:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix,FXString::value("%d-%d-%d-%d",glvisual->getActualAccumRedSize(),glvisual->getActualAccumGreenSize(),glvisual->getActualAccumBlueSize(),glvisual->getActualAccumAlphaSize()),NULL,LABEL_NORMAL);
label = new FXLabel(matrix,tr("Multi Sample:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix,FXString::value("%dx", glvisual->getActualMultiSamples()), nullptr, LABEL_NORMAL);
new FXTabItem(tabbook,tr(" Limits "));
matrix = new FXMatrix(tabbook, 2, MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED|FRAME_THICK);
GLint intvals[2] = {0, 0};
glGetIntegerv(GL_MAX_VIEWPORT_DIMS, intvals);
label = new FXLabel(matrix,tr("Viewport Size:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%d x %d", intvals[0], intvals[1]));
GLint intval(0);
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &intval);
label = new FXLabel(matrix,tr("Texture Size:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%d", intval));
#if defined(GL_MAX_TEXTURE_UNITS)
glGetIntegerv(GL_MAX_TEXTURE_UNITS, &intval);
label = new FXLabel(matrix, tr("Texture Units:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%d", intval));
#endif
glGetIntegerv(GL_MAX_LIGHTS, &intval);
label = new FXLabel(matrix,tr("Lights:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%d", intval));
glGetIntegerv(GL_MAX_CLIP_PLANES, &intval);
label = new FXLabel(matrix,tr("Clipping Planes:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%d", intval));
glGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH, &intval);
label = new FXLabel(matrix,tr("Modelview Stack:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%d", intval));
glGetIntegerv(GL_MAX_PROJECTION_STACK_DEPTH, &intval);
label = new FXLabel(matrix,tr("Projection Stack:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%d", intval));
glGetIntegerv(GL_MAX_ATTRIB_STACK_DEPTH, &intval);
label = new FXLabel(matrix, tr("Attribute Stack:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%d", intval));
label = new FXLabel(matrix, tr("Vertex Attributes:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
#if defined(GL_MAX_VERTEX_ATTRIBS)
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &intval);
new FXLabel(matrix, FXString::value("%d", intval));
#else
new FXLabel(matrix,"-");
#endif
label = new FXLabel(matrix, tr("Vertex Uniform Components:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
#if defined(GL_MAX_VERTEX_UNIFORM_COMPONENTS)
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &intval);
new FXLabel(matrix, FXString::value("%d", intval));
#else
new FXLabel(matrix, "-");
#endif
label = new FXLabel(matrix, tr("Fragment Uniform Components:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
#if defined(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS)
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &intval);
new FXLabel(matrix, FXString::value("%d", intval));
#else
new FXLabel(matrix, "-");
#endif
new FXTabItem(tabbook, tr(" Extensions "));
vframe = new FXVerticalFrame(tabbook, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED|FRAME_THICK);
vframe = new FXVerticalFrame(vframe, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, 0,0,0,0,0,0,0,0);
extensionlist = new FXList(vframe, nullptr, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y|HSCROLLING_OFF);
// Get OpenGL extensions
char* tmp = (char*)glGetString(GL_EXTENSIONS);
if (tmp) {
char* text = strdup(tmp);
char* token = strtok(text, " ");
while(token) {
extensionlist->appendItem(token);
token = strtok(nullptr, " ");
}
free(text);
}
extensionlist->setSortFunc(FXList::ascending);
extensionlist->sortItems();
// Get GLU extensions
#ifdef GLU_VERSION_1_1
tmp = (char*)gluGetString(GLU_EXTENSIONS);
if (tmp) {
char* text = strdup(tmp);
char* token = strtok(text, " ");
while (token != nullptr) {
extensionlist->appendItem(token);
token = strtok(nullptr, " ");
}
free(text);
}
#endif
new FXTabItem(tabbook, tr(" Driver "));
matrix = new FXMatrix(tabbook, 2, MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED|FRAME_THICK);
label = new FXLabel(matrix, tr("Vendor:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%s",glGetString(GL_VENDOR)), nullptr, LABEL_NORMAL);
label = new FXLabel(matrix, tr("Renderer:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%s",glGetString(GL_RENDERER)), nullptr, LABEL_NORMAL);
label = new FXLabel(matrix, tr("GL Version:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%s",glGetString(GL_VERSION)), nullptr, LABEL_NORMAL);
label = new FXLabel(matrix, tr("GLU Version:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT);
label->setFont(thickfont);
new FXLabel(matrix, FXString::value("%s", gluGetString(GLU_VERSION)), nullptr, LABEL_NORMAL);
canvas->makeNonCurrent();
}
static Q3ListViewItem *get_gl_info(Display *dpy, int scrnum, Bool allowDirect,Q3ListViewItem *l1, Q3ListViewItem *after)
{
Window win;
int attribSingle[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
None };
int attribDouble[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER,
None };
XSetWindowAttributes attr;
unsigned long mask;
Window root;
GLXContext ctx;
XVisualInfo *visinfo;
int width = 100, height = 100;
Q3ListViewItem *result = after;
root = RootWindow(dpy, scrnum);
visinfo = glXChooseVisual(dpy, scrnum, attribSingle);
if (!visinfo) {
visinfo = glXChooseVisual(dpy, scrnum, attribDouble);
if (!visinfo) {
kDebug() << "Error: couldn't find RGB GLX visual\n";
return result;
}
}
attr.background_pixel = 0;
attr.border_pixel = 0;
attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
attr.event_mask = StructureNotifyMask | ExposureMask;
mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
win = XCreateWindow(dpy, root, 0, 0, width, height,
0, visinfo->depth, InputOutput,
visinfo->visual, mask, &attr);
ctx = glXCreateContext( dpy, visinfo, NULL, allowDirect );
if (!ctx) {
kDebug() << "Error: glXCreateContext failed\n";
XDestroyWindow(dpy, win);
return result;
}
if (glXMakeCurrent(dpy, win, ctx)) {
gli.serverVendor = glXQueryServerString(dpy, scrnum, GLX_VENDOR);
gli.serverVersion = glXQueryServerString(dpy, scrnum, GLX_VERSION);
gli.serverExtensions = glXQueryServerString(dpy, scrnum, GLX_EXTENSIONS);
gli.clientVendor = glXGetClientString(dpy, GLX_VENDOR);
gli.clientVersion = glXGetClientString(dpy, GLX_VERSION);
gli.clientExtensions = glXGetClientString(dpy, GLX_EXTENSIONS);
gli.glxExtensions = glXQueryExtensionsString(dpy, scrnum);
gli.glVendor = (const char *) glGetString(GL_VENDOR);
gli.glRenderer = (const char *) glGetString(GL_RENDERER);
gli.glVersion = (const char *) glGetString(GL_VERSION);
gli.glExtensions = (const char *) glGetString(GL_EXTENSIONS);
gli.displayName = NULL;
#ifdef KCMGL_DO_GLU
gli.gluVersion = (const char *) gluGetString(GLU_VERSION);
gli.gluExtensions = (const char *) gluGetString(GLU_EXTENSIONS);
#endif
IsDirect = glXIsDirect(dpy, ctx);
result = print_screen_info(l1, after);
}
else {
kDebug() << "Error: glXMakeCurrent failed\n";
glXDestroyContext(dpy, ctx);
}
glXDestroyContext(dpy, ctx);
XDestroyWindow(dpy, win);
return result;
}
// Save OpenGL info to a file
FXbool SettingsDialog::saveInformation(const FXString& filename)
{
FILE* fp = std::fopen(filename.text(),"w");
if (fp) {
FXGLVisual *glvisual = static_cast<FXGLVisual*>(canvas->getVisual());
canvas->makeCurrent();
std::fprintf(fp,"Driver Information\n");
std::fprintf(fp,"------------------\n");
std::fprintf(fp,"\n");
std::fprintf(fp," Vendor: %s\n", glGetString(GL_VENDOR));
std::fprintf(fp," Renderer: %s\n", glGetString(GL_RENDERER));
std::fprintf(fp," GL Version: %s\n", glGetString(GL_VERSION));
std::fprintf(fp," GLU Version: %s\n", gluGetString(GLU_VERSION));
std::fprintf(fp,"\n");
std::fprintf(fp,"Implementation Limits\n");
std::fprintf(fp,"---------------------\n");
std::fprintf(fp,"\n");
GLint intval(0);
GLint intvals[2] = {0, 0};
glGetIntegerv(GL_MAX_VIEWPORT_DIMS, intvals);
std::fprintf(fp," Viewport Size: %d x %d\n", intvals[0], intvals[1]);
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &intval);
std::fprintf(fp," Texture Size: %d\n", intval);
#if defined(GL_MAX_TEXTURE_UNITS)
glGetIntegerv(GL_MAX_TEXTURE_UNITS, &intval);
std::fprintf(fp," Texture Units: %d\n", intval);
#endif
glGetIntegerv(GL_MAX_LIGHTS, &intval);
std::fprintf(fp," Lights: %d\n", intval);
glGetIntegerv(GL_MAX_CLIP_PLANES, &intval);
std::fprintf(fp," Clipping Planes: %d\n", intval);
glGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH,&intval);
std::fprintf(fp," Modelview Stack: %d\n", intval);
glGetIntegerv(GL_MAX_PROJECTION_STACK_DEPTH,&intval);
std::fprintf(fp," Projection Stack: %d\n", intval);
glGetIntegerv(GL_MAX_ATTRIB_STACK_DEPTH,&intval);
std::fprintf(fp," Attribute Stack: %d\n", intval);
#if defined(GL_MAX_VERTEX_ATTRIBS)
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &intval);
std::fprintf(fp," Vertex Attributes: %d\n", intval);
#else
std::fprintf(fp," Vertex Attributes: -\n");
#endif
#if defined(GL_MAX_VERTEX_UNIFORM_COMPONENTS)
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &intval);
std::fprintf(fp," Vertex Uniform Components: %d\n", intval);
#else
std::fprintf(fp," Vertex Uniform Components: -\n");
#endif
#if defined(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS)
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &intval);
std::fprintf(fp," Fragment Uniform Components: %d\n", intval);
#else
std::fprintf(fp," Fragment Uniform Components: -\n");
#endif
std::fprintf(fp,"\n");
std::fprintf(fp,"Display Mode\n");
std::fprintf(fp,"------------\n");
std::fprintf(fp,"\n");
std::fprintf(fp," Hardware Accelerated: %s\n", PRINT_YESNO(glvisual->isAccelerated()));
std::fprintf(fp," Double Buffering: %s\n", PRINT_YESNO(glvisual->isDoubleBuffer()));
std::fprintf(fp," Stereo View: %s\n", PRINT_YESNO(glvisual->isStereo()));
std::fprintf(fp," Buffer-swap by copy: %s\n", PRINT_YESNO(glvisual->isBufferSwapCopy()));
std::fprintf(fp," Color Depth: %d\n", glvisual->getActualRedSize()+glvisual->getActualGreenSize()+glvisual->getActualBlueSize()+glvisual->getActualAlphaSize());
std::fprintf(fp," Depth Buffer Size: %d\n", glvisual->getActualDepthSize());
std::fprintf(fp," Stencil Buffer Size: %d\n", glvisual->getActualStencilSize());
std::fprintf(fp," RGBA: %d-%d-%d-%d\n", glvisual->getActualRedSize(), glvisual->getActualGreenSize(), glvisual->getActualBlueSize(), glvisual->getActualAlphaSize());
std::fprintf(fp," Accum RGBA: %d-%d-%d-%d\n", glvisual->getActualAccumRedSize(), glvisual->getActualAccumGreenSize(), glvisual->getActualAccumBlueSize(), glvisual->getActualAccumAlphaSize());
std::fprintf(fp," Multi Sample: %d\n", glvisual->getActualMultiSamples());
std::fprintf(fp,"\n");
std::fprintf(fp,"Available Extensions\n");
std::fprintf(fp,"--------------------\n");
std::fprintf(fp,"\n");
for (FXint i=0; i < extensionlist->getNumItems(); i++) {
std::fprintf(fp, " %s\n", extensionlist->getItemText(i).text());
}
canvas->makeNonCurrent();
std::fclose(fp);
return true;
}
return false;
}
void glu_getstring( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) {
plhs[0]=mxCreateString((const char *)gluGetString((GLenum)mxGetScalar(prhs[0])));
}
void COpenGLExtensionHandler::initExtensions(bool stencilBuffer)
{
const f32 ver = (f32)atof((c8*)glGetString(GL_VERSION));
Version = core::floor32(ver)*100+(s32)(ver-floor(ver));
if ( Version >= 102)
os::Printer::log("OpenGL driver version is 1.2 or better.", ELL_INFORMATION);
else
os::Printer::log("OpenGL driver version is not 1.2 or better.", ELL_WARNING);
const GLubyte* t = glGetString(GL_EXTENSIONS);
// os::Printer::log((const c8*)t, ELL_INFORMATION);
#ifdef GLU_VERSION_1_3
const GLubyte* gluVersion = gluGetString(GLU_VERSION);
if (gluVersion[0]>1 || gluVersion[3]>2)
{
for (u32 i=0; i<IRR_OpenGL_Feature_Count; ++i)
FeatureAvailable[i] = gluCheckExtension((const GLubyte*)OpenGLFeatureStrings[i], t);
}
else
#endif
{
s32 len = (s32)strlen((const char*)t);
c8 *str = new c8[len+1];
c8* p = str;
for (s32 i=0; i<len; ++i)
{
str[i] = (char)t[i];
if (str[i] == ' ')
{
str[i] = 0;
for (u32 i=0; i<IRR_OpenGL_Feature_Count; ++i)
if (strstr(p, OpenGLFeatureStrings[i]))
FeatureAvailable[i] = true;
p = p + strlen(p) + 1;
}
}
delete [] str;
}
MultiTextureExtension = FeatureAvailable[IRR_ARB_multitexture];
MultiSamplingExtension = FeatureAvailable[IRR_ARB_multisample];
AnisotropyExtension = FeatureAvailable[IRR_EXT_texture_filter_anisotropic];
SeparateStencilExtension = FeatureAvailable[IRR_ATI_separate_stencil];
TextureCompressionExtension = FeatureAvailable[IRR_ARB_texture_compression];
PackedDepthStencilExtension = FeatureAvailable[IRR_EXT_packed_depth_stencil];
SeparateSpecularColorExtension = FeatureAvailable[IRR_EXT_separate_specular_color];
StencilBuffer=stencilBuffer;
#ifdef _IRR_WINDOWS_API_
// get multitexturing function pointers
pGlActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress("glActiveTextureARB");
pGlClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) wglGetProcAddress("glClientActiveTextureARB");
// get fragment and vertex program function pointers
pGlGenProgramsARB = (PFNGLGENPROGRAMSARBPROC) wglGetProcAddress("glGenProgramsARB");
pGlBindProgramARB = (PFNGLBINDPROGRAMARBPROC) wglGetProcAddress("glBindProgramARB");
pGlProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC) wglGetProcAddress("glProgramStringARB");
pGlDeleteProgramsARB = (PFNGLDELETEPROGRAMSNVPROC) wglGetProcAddress("glDeleteProgramsARB");
pGlProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) wglGetProcAddress("glProgramLocalParameter4fvARB");
pGlCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC) wglGetProcAddress("glCreateShaderObjectARB");
pGlShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) wglGetProcAddress("glShaderSourceARB");
pGlCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) wglGetProcAddress("glCompileShaderARB");
pGlCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC) wglGetProcAddress("glCreateProgramObjectARB");
pGlAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) wglGetProcAddress("glAttachObjectARB");
pGlLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) wglGetProcAddress("glLinkProgramARB");
pGlUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) wglGetProcAddress("glUseProgramObjectARB");
pGlDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) wglGetProcAddress("glDeleteObjectARB");
pGlGetInfoLogARB = (PFNGLGETINFOLOGARBPROC) wglGetProcAddress("glGetInfoLogARB");
pGlGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC) wglGetProcAddress("glGetObjectParameterivARB");
pGlGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC) wglGetProcAddress("glGetUniformLocationARB");
pGlUniform4fvARB = (PFNGLUNIFORM4FVARBPROC) wglGetProcAddress("glUniform4fvARB");
pGlUniform1ivARB = (PFNGLUNIFORM1IVARBPROC) wglGetProcAddress("glUniform1ivARB");
pGlUniform1fvARB = (PFNGLUNIFORM1FVARBPROC) wglGetProcAddress("glUniform1fvARB");
pGlUniform2fvARB = (PFNGLUNIFORM2FVARBPROC) wglGetProcAddress("glUniform2fvARB");
pGlUniform3fvARB = (PFNGLUNIFORM3FVARBPROC) wglGetProcAddress("glUniform3fvARB");
pGlUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC) wglGetProcAddress("glUniformMatrix2fvARB");
pGlUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC) wglGetProcAddress("glUniformMatrix3fvARB");
pGlUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC) wglGetProcAddress("glUniformMatrix4fvARB");
pGlGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC) wglGetProcAddress("glGetActiveUniformARB");
// get point parameter extension
pGlPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC) wglGetProcAddress("glPointParameterfARB");
pGlPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC) wglGetProcAddress("glPointParameterfvARB");
// get stencil extension
pGlStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) wglGetProcAddress("glStencilFuncSeparate");
pGlStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) wglGetProcAddress("glStencilOpSeparate");
pGlStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC) wglGetProcAddress("glStencilFuncSeparateATI");
pGlStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC) wglGetProcAddress("glStencilOpSeparateATI");
// compressed textures
#ifdef PFNGLCOMPRESSEDTEXIMAGE2DPROC
pGlCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) wglGetProcAddress("glCompressedTexImage2D");
#endif
// FrameBufferObjects
pGlBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC) wglGetProcAddress("glBindFramebufferEXT");
pGlDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC) wglGetProcAddress("glDeleteFramebuffersEXT");
pGlGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC) wglGetProcAddress("glGenFramebuffersEXT");
pGlCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) wglGetProcAddress("glCheckFramebufferStatusEXT");
pGlFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) wglGetProcAddress("glFramebufferTexture2DEXT");
pGlBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC) wglGetProcAddress("glBindRenderbufferEXT");
pGlDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC) wglGetProcAddress("glDeleteRenderbuffersEXT");
pGlGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC) wglGetProcAddress("glGenRenderbuffersEXT");
pGlRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC) wglGetProcAddress("glRenderbufferStorageEXT");
pGlFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) wglGetProcAddress("glFramebufferRenderbufferEXT");
// vsync extension
wglSwapIntervalEXT = (PFNWGLSWAPINTERVALFARPROC)wglGetProcAddress( "wglSwapIntervalEXT" );
#elif defined(_IRR_USE_LINUX_DEVICE_) || defined (_IRR_USE_SDL_DEVICE_)
#ifdef _IRR_OPENGL_USE_EXTPOINTER_
#ifdef _IRR_USE_SDL_DEVICE_
#define IRR_OGL_LOAD_EXTENSION(x) SDL_GL_GetProcAddress(reinterpret_cast<const char*>(x))
#else
// Accessing the correct function is quite complex
// All libraries should support the ARB version, however
// since GLX 1.4 the non-ARB version is the official one
// So we have to check the runtime environment and
// choose the proper symbol
// In case you still have problems please enable the
// next line by uncommenting it
// #define _IRR_GETPROCADDRESS_WORKAROUND_
#ifndef _IRR_GETPROCADDRESS_WORKAROUND_
__GLXextFuncPtr (*IRR_OGL_LOAD_EXTENSION)(const GLubyte*)=0;
#ifdef GLX_VERSION_1_4
int major,minor;
glXQueryVersion(glXGetCurrentDisplay(), &major, &minor);
if ((major>1) || (minor>3))
IRR_OGL_LOAD_EXTENSION=glXGetProcAddress;
else
#endif
IRR_OGL_LOAD_EXTENSION=glXGetProcAddressARB;
#else
#define IRR_OGL_LOAD_EXTENSION glXGetProcAddressARB
#endif
#endif
pGlActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glActiveTextureARB"));
pGlClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glClientActiveTextureARB"));
// get fragment and vertex program function pointers
pGlGenProgramsARB = (PFNGLGENPROGRAMSARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGenProgramsARB"));
pGlBindProgramARB = (PFNGLBINDPROGRAMARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glBindProgramARB"));
pGlProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glProgramStringARB"));
pGlDeleteProgramsARB = (PFNGLDELETEPROGRAMSNVPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glDeleteProgramsARB"));
pGlProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glProgramLocalParameter4fvARB"));
pGlCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glCreateShaderObjectARB"));
pGlShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glShaderSourceARB"));
pGlCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glCompileShaderARB"));
pGlCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glCreateProgramObjectARB"));
pGlAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glAttachObjectARB"));
pGlLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glLinkProgramARB"));
pGlUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUseProgramObjectARB"));
pGlDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glDeleteObjectARB"));
pGlGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGetInfoLogARB"));
pGlGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGetObjectParameterivARB"));
pGlGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGetUniformLocationARB"));
pGlUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniform4fvARB"));
pGlUniform1ivARB = (PFNGLUNIFORM1IVARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniform1ivARB"));
pGlUniform1fvARB = (PFNGLUNIFORM1FVARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniform1fvARB"));
pGlUniform2fvARB = (PFNGLUNIFORM2FVARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniform2fvARB"));
pGlUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniform3fvARB"));
pGlUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniform4fvARB"));
pGlUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniformMatrix2fvARB"));
pGlUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniformMatrix3fvARB"));
pGlUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniformMatrix4fvARB"));
pGlGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGetActiveUniformARB"));
// get point parameter extension
pGlPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glPointParameterfARB"));
pGlPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glPointParameterfvARB"));
// get stencil extension
pGlStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glStencilFuncSeparate"));
pGlStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glStencilOpSeparate"));
pGlStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glStencilFuncSeparateATI"));
pGlStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glStencilOpSeparateATI"));
// compressed textures
#ifdef PFNGLCOMPRESSEDTEXIMAGE2DPROC
pGlCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glCompressedTexImage2D"));
#endif
#if defined(GLX_SGI_swap_control) && !defined(_IRR_USE_SDL_DEVICE_)
// get vsync extension
glxSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glXSwapIntervalSGI"));
#endif
// FrameBufferObjects
pGlBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glBindFramebufferEXT"));
pGlDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glDeleteFramebuffersEXT"));
pGlGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGenFramebuffersEXT"));
pGlCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glCheckFramebufferStatusEXT"));
pGlFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glFramebufferTexture2DEXT"));
pGlBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glBindRenderbufferEXT"));
pGlDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glDeleteRenderbuffersEXT"));
pGlGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGenRenderbuffersEXT"));
pGlRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glRenderbufferStorageEXT"));
pGlFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)
IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glFramebufferRenderbufferEXT"));
#endif // _IRR_OPENGL_USE_EXTPOINTER_
#endif // _IRR_WINDOWS_API_
// set some properties
glGetIntegerv(GL_MAX_TEXTURE_UNITS, &MaxTextureUnits);
glGetIntegerv(GL_MAX_LIGHTS, &MaxLights);
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &MaxAnisotropy);
#ifdef _IRR_OPENGL_USE_EXTPOINTER_
if (!pGlActiveTextureARB || !pGlClientActiveTextureARB)
{
MultiTextureExtension = false;
os::Printer::log("Failed to load OpenGL's multitexture extension, proceeding without.", ELL_WARNING);
}
else
#endif
if (MaxTextureUnits < 2)
{
MultiTextureExtension = false;
os::Printer::log("Warning: OpenGL device only has one texture unit. Disabling multitexturing.", ELL_WARNING);
}
MaxTextureUnits = core::min_((u32)MaxTextureUnits,MATERIAL_MAX_TEXTURES);
glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &MaxIndices);
}
int
main (int argc, char** argv)
{
GLenum err;
GLContext ctx;
/* ---------------------------------------------------------------------- */
/* parse arguments */
if (GL_TRUE == ParseArgs(argc-1, argv+1))
{
#if defined(_WIN32)
fprintf(stderr, "Usage: visualinfo [-a] [-s] [-h] [-pf <id>]\n");
fprintf(stderr, " -a: show all visuals\n");
fprintf(stderr, " -s: display to stdout instead of visualinfo.txt\n");
fprintf(stderr, " -pf <id>: use given pixelformat\n");
fprintf(stderr, " -h: this screen\n");
#else
fprintf(stderr, "Usage: visualinfo [-h] [-display <display>] [-visual <id>]\n");
fprintf(stderr, " -h: this screen\n");
fprintf(stderr, " -display <display>: use given display\n");
fprintf(stderr, " -visual <id>: use given visual\n");
#endif
return 1;
}
/* ---------------------------------------------------------------------- */
/* create OpenGL rendering context */
InitContext(&ctx);
if (GL_TRUE == CreateContext(&ctx))
{
fprintf(stderr, "Error: CreateContext failed\n");
DestroyContext(&ctx);
return 1;
}
/* ---------------------------------------------------------------------- */
/* initialize GLEW */
glewExperimental = GL_TRUE;
#ifdef GLEW_MX
err = glewContextInit(glewGetContext());
# ifdef _WIN32
err = err || wglewContextInit(wglewGetContext());
# elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
err = err || glxewContextInit(glxewGetContext());
# endif
#else
err = glewInit();
#endif
if (GLEW_OK != err)
{
fprintf(stderr, "Error [main]: glewInit failed: %s\n", glewGetErrorString(err));
DestroyContext(&ctx);
return 1;
}
/* ---------------------------------------------------------------------- */
/* open file */
#if defined(_WIN32)
if (!displaystdout)
file = fopen("visualinfo.txt", "w");
if (file == NULL)
file = stdout;
#else
file = stdout;
#endif
/* ---------------------------------------------------------------------- */
/* output header information */
/* OpenGL extensions */
fprintf(file, "OpenGL vendor string: %s\n", glGetString(GL_VENDOR));
fprintf(file, "OpenGL renderer string: %s\n", glGetString(GL_RENDERER));
fprintf(file, "OpenGL version string: %s\n", glGetString(GL_VERSION));
fprintf(file, "OpenGL extensions (GL_): \n");
PrintExtensions((char*)glGetString(GL_EXTENSIONS));
/* GLU extensions */
fprintf(file, "GLU version string: %s\n", gluGetString(GLU_VERSION));
fprintf(file, "GLU extensions (GLU_): \n");
PrintExtensions((char*)gluGetString(GLU_EXTENSIONS));
/* ---------------------------------------------------------------------- */
/* extensions string */
#if defined(_WIN32)
/* WGL extensions */
if (WGLEW_ARB_extensions_string || WGLEW_EXT_extensions_string)
{
fprintf(file, "WGL extensions (WGL_): \n");
PrintExtensions(wglGetExtensionsStringARB ?
(char*)wglGetExtensionsStringARB(ctx.dc) :
(char*)wglGetExtensionsStringEXT());
}
#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
#else
/* GLX extensions */
fprintf(file, "GLX extensions (GLX_): \n");
PrintExtensions(glXQueryExtensionsString(glXGetCurrentDisplay(),
DefaultScreen(glXGetCurrentDisplay())));
#endif
/* ---------------------------------------------------------------------- */
/* enumerate all the formats */
VisualInfo(&ctx);
/* ---------------------------------------------------------------------- */
/* release resources */
DestroyContext(&ctx);
if (file != stdout)
fclose(file);
return 0;
}
//===========================================================================
// DG_Init
// 'mode' is either DGL_MODE_WINDOW or DGL_MODE_FULLSCREEN. If 'bpp' is
// zero, the current display color depth is used.
//===========================================================================
int DG_Init(int width, int height, int bpp, int mode)
{
boolean fullscreen = (mode == DGL_MODE_FULLSCREEN);
char *token, *extbuf;
const SDL_VideoInfo *info = NULL;
Con_Message("DG_Init: OpenGL.\n");
// Are we in range here?
/* if(!fullscreen)
{
if(width > GetSystemMetrics(SM_CXSCREEN))
width = GetSystemMetrics(SM_CXSCREEN);
if(height > GetSystemMetrics(SM_CYSCREEN))
height = GetSystemMetrics(SM_CYSCREEN);
}
*/
info = SDL_GetVideoInfo();
screenBits = info->vfmt->BitsPerPixel;
screenWidth = width;
screenHeight = height;
windowed = !fullscreen;
allowCompression = true;
verbose = ArgExists("-verbose");
// Set GL attributes. We want at least 5 bits per color and a 16
// bit depth buffer. Plus double buffering, of course.
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
/*
if(fullscreen)
{
if(!fullscreenMode(screenWidth, screenHeight, bpp))
{
Con_Error("drOpenGL.Init: Resolution change failed (%d x %d).\n",
screenWidth, screenHeight);
}
}
else
{
windowedMode(screenWidth, screenHeight);
}
*/
if(!initOpenGL())
{
Con_Error("drOpenGL.Init: OpenGL init failed.\n");
}
// Clear the buffers.
DG_Clear(DGL_COLOR_BUFFER_BIT | DGL_DEPTH_BUFFER_BIT);
token = (char *) glGetString(GL_EXTENSIONS);
extbuf = malloc(strlen(token) + 1);
strcpy(extbuf, token);
// Check the maximum texture size.
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTexSize);
initExtensions();
if(firstTimeInit)
{
firstTimeInit = DGL_FALSE;
// Print some OpenGL information (console must be initialized by now).
Con_Message("OpenGL information:\n");
Con_Message(" Vendor: %s\n", glGetString(GL_VENDOR));
Con_Message(" Renderer: %s\n", glGetString(GL_RENDERER));
Con_Message(" Version: %s\n", glGetString(GL_VERSION));
Con_Message(" Extensions:\n");
// Show the list of GL extensions.
token = strtok(extbuf, " ");
while(token)
{
Con_Message(" "); // Indent.
if(verbose)
{
// Show full names.
Con_Message("%s\n", token);
}
else
{
// Two on one line, clamp to 30 characters.
Con_Message("%-30.30s", token);
token = strtok(NULL, " ");
if(token)
Con_Message(" %-30.30s", token);
Con_Message("\n");
}
token = strtok(NULL, " ");
}
Con_Message(" GLU Version: %s\n", gluGetString(GLU_VERSION));
glGetIntegerv(GL_MAX_TEXTURE_UNITS, &maxTexUnits);
#ifndef USE_MULTITEXTURE
maxTexUnits = 1;
#endif
// But sir, we are simple people; two units is enough.
if(maxTexUnits > 2)
maxTexUnits = 2;
Con_Message(" Texture units: %i\n", maxTexUnits);
Con_Message(" Maximum texture size: %i\n", maxTexSize);
if(extAniso)
{
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAniso);
Con_Message(" Maximum anisotropy: %g\n", maxAniso);
}
//if(!noArrays) Con_Message(" Using vertex arrays.\n");
}
free(extbuf);
// Decide whether vertex arrays should be done manually or with real
// OpenGL calls.
InitArrays();
if(ArgCheck("-dumptextures"))
{
dumpTextures = DGL_TRUE;
Con_Message(" Dumping textures (mipmap level zero).\n");
}
if(extAniso && ArgExists("-anifilter"))
{
useAnisotropic = DGL_TRUE;
Con_Message(" Using anisotropic texture filtering.\n");
}
return DGL_OK;
}
