void Renderer::checkGlCaps() {
if(glActiveTexture == NULL) {
string message;
message += "Your system supports OpenGL version \"";
message += getGlVersion() + string("\"\n");
message += "MegaGlest needs a version that supports\n";
message += "glActiveTexture (OpenGL 1.3) or the ARB_multitexture extension.";
throw megaglest_runtime_error(message.c_str());
}
//opengl 1.3
//if(!isGlVersionSupported(1, 3, 0)) {
if(glewIsSupported("GL_VERSION_1_3") == false) {
string message;
message += "Your system supports OpenGL version \"";
message += getGlVersion() + string("\"\n");
message += "MegaGlest needs at least version 1.3 to work\n";
message += "You may solve this problem by installing your latest video card drivers";
throw megaglest_runtime_error(message.c_str());
}
//opengl 1.4 or extension
//if(isGlVersionSupported(1, 4, 0) == false) {
if(glewIsSupported("GL_VERSION_1_4") == false) {
checkExtension("GL_ARB_texture_env_crossbar", "MegaGlest");
}
}
void initShader(char* shaderName, int id ) {
int success = 0;
int gl_major, gl_minor;
GLchar *VertexShaderSource,
*FragmentShaderSource;
glewInit();
// Make sure that OpenGL 2.0 is supported by the driver
getGlVersion(&gl_major, &gl_minor);
printf("GL_VERSION major=%d minor=%d\n", gl_major, gl_minor);
if (gl_major < 2) {
printf("GL_VERSION major=%d minor=%d\n", gl_major, gl_minor);
printf("Support for OpenGL 2.0 is required for this demo...exiting\n");
exit(1);
}
readShaderSource(shaderName, &VertexShaderSource, &FragmentShaderSource);
success = installShaders(VertexShaderSource, FragmentShaderSource, id);
if (!success) {
printf("Fail to load Shaders!!\n");
exit(0);
}
}
bool isGlVersionSupported(int major, int minor, int release) {
int majorVersion, minorVersion, releaseVersion;
getGlVersion(majorVersion, minorVersion, releaseVersion);
// major
if (majorVersion < major) {
return false;
} else if (majorVersion > major) {
return true;
}
// minor
if (minorVersion < minor) {
return false;
} else if (minorVersion > minor) {
return true;
}
// release
if (releaseVersion < release) {
return false;
}
return true;
}
void getGlslVersion(int *major, int *minor)
{
int gl_major, gl_minor;
getGlVersion(&gl_major, &gl_minor);
*major = *minor = 0;
if (gl_major == 1)
{
/* GL v1.x can only provide GLSL v1.00 as an extension */
const char *extstr = (const char *) glGetString(GL_EXTENSIONS);
if ((extstr != NULL) &&
(strstr(extstr, "GL_ARB_shading_language_100") != NULL))
{
*major = 1;
*minor = 0;
}
}
else if (gl_major >= 2)
{
/* GL v2.0 and greater must parse the version string */
const char *verstr =
(const char *) glGetString(GL_SHADING_LANGUAGE_VERSION);
if((verstr == NULL) ||
(sscanf(verstr, "%d.%d", major, minor) != 2))
{
*major = *minor = 0;
fprintf(stderr,
"Invalid GL_SHADING_LANGUAGE_VERSION format!!!\n");
}
}
}
void getGlVersion(int &major, int &minor, int &release) {
const char *strVersion = getGlVersion();
char *tokString = new char[strlen(strVersion) + 1];
strcpy(tokString, strVersion);
major = atoi(strtok(tokString, "."));
minor = atoi(strtok(0, "."));
release = atoi(strtok(0, "."));
delete [] tokString;
}
int main( int argc, char **argv )
{
int success = 0;
int gl_major, gl_minor;
GLchar *VertexShaderSource, *FragmentShaderSource;
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(500, 500);
window = glutCreateWindow( "3Dlabs Brick Shader");
glutIdleFunc(play);
glutDisplayFunc(display);
glutKeyboardFunc(key);
glutReshapeFunc(reshape);
glutMotionFunc(motion);
glutMouseFunc(mouse);
glutSpecialFunc(special);
glutTimerFunc(TIMER_FREQUENCY_MILLIS , timer, 0);
// Initialize the "OpenGL Extension Wrangler" library
glewInit();
// Make sure that OpenGL 2.0 is supported by the driver
getGlVersion(&gl_major, &gl_minor);
printf("GL_VERSION major=%d minor=%d\n", gl_major, gl_minor);
if (gl_major < 2)
{
printf("GL_VERSION major=%d minor=%d\n", gl_major, gl_minor);
printf("Support for OpenGL 2.0 is required for this demo...exiting\n");
exit(1);
}
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
NextClearColor();
key('?', 0, 0); // display help
#if 0
readShaderSource("brick", &VertexShaderSource, &FragmentShaderSource);
#else
readShaderSource("cloud", &VertexShaderSource, &FragmentShaderSource);
#endif
success = installBrickShaders(VertexShaderSource, FragmentShaderSource);
CreateNoise3D();
if (success)
glutMainLoop();
return 0;
}
int check_gl2()
{
int major, minor;
getGlVersion(&major, &minor);
if (major < 2)
{
printf("OpenGL 2.0 not supported\n");
exit(0);
}
return 0;
}
bool glInit()
{
if (gl3wInit())
{
printf("Problem initializing OpenGL\n");
return false;
}
int maj, min, slmaj, slmin;
getGlVersion(&maj, &min);
getGlslVersion(&slmaj, &slmin);
printf("OpenGL version: %d.%d\n", maj, min);
printf("GLSL version: %d.%d\n", slmaj, slmin);
return true;
}
/*
* Main
*
******************************************************************************/
int main( int argc, char **argv )
{
int success = 0;
int gl_major, gl_minor;
GLchar *VertexShaderSource, *FragmentShaderSource;
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(500, 500);
window = glutCreateWindow( "Temperature Shader");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
// Initialize the "OpenGL Extension Wrangler" library
glewInit();
// Make sure that OpenGL 2.0 is supported by the driver
getGlVersion(&gl_major, &gl_minor);
printf("GL_VERSION major=%d minor=%d\n", gl_major, gl_minor);
if (gl_major < 2)
{
printf("GL_VERSION major=%d minor=%d\n", gl_major, gl_minor);
printf("Support for OpenGL 2.0 is required for this demo...exiting\n");
exit(1);
}
readShaderSource("temp", &VertexShaderSource, &FragmentShaderSource);
success = installShaders(VertexShaderSource, FragmentShaderSource);
if (success)
glutMainLoop();
return 0;
}
void begin()
{
// old-BATB didn't like to be initialized more than once :(
// hence, ignore re-init for specified parts, and continue with previous state
static bool empty = true;
// clear exit, making possible to start over again
//do_exit = false;
// copied from old::main:
//MainWindow::winPosX = 100;
//MainWindow::winPosY = 100;
//MainWindow::winWidth = 640;
//MainWindow::winHeight = 480;
// init glut
//glutInitWindowPosition(MainWindow::winPosX, MainWindow::winPosY);
//glutInitWindowSize (MainWindow::winWidth, MainWindow::winHeight);
//glutInit (&argc, argv);
//glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
//MainWindow::main_window = glutCreateWindow("Beat About the Bush");
MainWindow::enableDisplayFunc();
// implemented as GLFW:
GLFWwindow* win = glfwGetCurrentContext();
glfwSetKeyCallback( win, MainWindow::glfwKey ); //glutKeyboardFunc (MainWindow::keyDownFn);
//glutSpecialFunc (MainWindow::specialDownFn);
////glutKeyboardUpFunc (MainWindow::keyUpFn);
////glutSpecialUpFunc (MainWindow::specialUpFn);
glfwSetCursorPosCallback( win, MainWindow::glfwCursorPos ); //glutMouseFunc (MainWindow::mousefn);
glfwSetMouseButtonCallback( win, MainWindow::glfwMouseButton); //glutMotionFunc (MainWindow::motionfn);
glfwSetWindowSizeCallback( win, MainWindow::glfwWindowSize ); //glutReshapeFunc (MainWindow::reshapefn);
glfwSetWindowFocusCallback( win, MainWindow::glfwWindowFocus ); //glutVisibilityFunc (MainWindow::visibility);
if ( empty )
{
// init plib, with no GLUT-binding!
puInitOLD();
puSetDefaultStyle ( PUSTYLE_SMALL_SHADED );
puSetDefaultColourScheme ( 0.3f, 0.4f, 0.6f, 1.0f);
// Initialize the "OpenGL Extension Wrangler" library
//glewInit();
}
mainWindow.initLights();
if ( empty )
{
mainWindow.init();
printVersions();
// Make sure that OpenGL 2.0 is supported by the driver
int gl_major, gl_minor;
getGlVersion(&gl_major, &gl_minor);
printf("GL_VERSION major=%d minor=%d\n", gl_major, gl_minor);
if (gl_major < 2)
{
printf("GL_VERSION major=%d minor=%d\n", gl_major, gl_minor);
printf("Support for OpenGL 2.0 is required for this demo...exiting\n");
//exit(1);
old::exit(1);
return;
}
// init shaders
GLchar *dayVSSource, *dayFSSource;
readShaderSource( old::file("shader/day").c_str(), &dayVSSource, &dayFSSource);
dayShader = installShaders(dayVSSource, dayFSSource);
float forestGreen[] = {34.0/255, 139.0/255, 34.0/255};
//float auburn[] = {113.0/255, 47.0/255, 38.0/255};
float grey[] = {0.5, 0.5, 0.5};
//float sepia[] = {112.0/255, 66.0/255, 20.0/255};
setUniform3f(dayShader, "GrassColor", forestGreen[0], forestGreen[1], forestGreen[2]);
setUniform3f(dayShader, "RockColor", grey[0], grey[1], grey[2]);
//setUniform3f(dayShader, "DirtColor", sepia[0], sepia[1], sepia[2]);
//setUniform4f(dayShader, "LightPos", 0.0, 0.0, 100.0, 1.0);
setUniform1f(dayShader, "Scale", 1.0);
setUniform1f(dayShader, "TerrainHigh", 0.1);
setUniform1f(dayShader, "TerrainLow", 0.1);
setUniform1i(dayShader, "Trees", 0); // sampler
setUniform1i(dayShader, "AltGrad", 1); // sampler
setUniform1i(dayShader, "Noise", 2); // sampler
GLchar *nightVSSource, *nightFSSource;
readShaderSource( old::file("shader/night3").c_str(), &nightVSSource, &nightFSSource);
nightShader = installShaders(nightVSSource, nightFSSource);
setUniform3f(nightShader, "BrickColor", 1.0, 0.3, 0.2);
setUniform3f(nightShader, "MortarColor", 0.85, 0.86, 0.84);
setUniform2f(nightShader, "BrickSize", 0.30, 0.15);
setUniform2f(nightShader, "BrickPct", 0.90, 0.85);
setUniform1i(nightShader, "numEnabledLights", 2);
setUniform3f(nightShader, "GrassColor", forestGreen[0], forestGreen[1], forestGreen[2]);
setUniform3f(nightShader, "RockColor", grey[0], grey[1], grey[2]);
setUniform1f(nightShader, "Scale", 1.0);
setUniform1f(nightShader, "TerrainHigh", 0.1);
setUniform1f(nightShader, "TerrainLow", 0.1);
setUniform1i(nightShader, "Trees", 0); // sampler
setUniform1i(nightShader, "AltGrad", 1); // sampler
setUniform1i(nightShader, "Noise", 2); // sampler
GLchar *nightTreeVS, *nightTreeFS;
readShaderSource( old::file("shader/nightTree").c_str(), &nightTreeVS, &nightTreeFS);
nightTrees = installShaders(nightTreeVS, nightTreeFS);
setUniform1i(nightTrees, "Trees", 0); // sampler
// BUGFIX:
free( dayVSSource );
free( dayFSSource );
free( nightVSSource );
free( nightFSSource );
free( nightTreeVS );
free( nightTreeFS );
}
// enter main loop
//if (dayShader && nightShader)
// glutMainLoop();
//return 0;
empty = false;
}
