bool agg_renderer<T>::setupOpenGL(Map const &m) {
// Start setting up OpenGL
int argc = 0;
char **argv = NULL;
glutInit(&argc, argv);
glutInitWindowSize(width_, height_);
glutCreateWindow("map_rendering");
glutHideWindow();
glutInitDisplayMode(GLUT_RGBA | GLUT_MULTISAMPLE | GLUT_DEPTH | GLUT_STENCIL);
int statusGlew = glewInit();
if (statusGlew != GLEW_OK) {
fprintf(stderr, "%s\n", "OpenGL Extension Wrangler (GLEW) failed to initialize");
exit(1);
}
// Disable Vsync
Display *dpy = glXGetCurrentDisplay();
GLXDrawable drawable = glXGetCurrentDrawable();
const int interval = 0;
if (drawable) {
glXSwapIntervalEXT(dpy, drawable, interval);
}
// Temporary disable
// if (!glewIsSupported("GL_EXT_direct_state_access")) {
// fprintf(stderr, "%s\n", "OpenGL implementation doesn't support GL_EXT_direct_state_access (you should be using NVIDIA GPUs...)");
// exit(1);
// }
initializeNVPR("Mapnik GPU");
if (!has_NV_path_rendering) {
fprintf(stderr, "%s\n", "required NV_path_rendering OpenGL extension is not present");
exit(1);
}
// Create initial shader program (srcOver)
// currentProgram_ = createProgram(src_over);
// currentShader_ = src_over;
// glUseProgram(currentProgram_);
// checkOpenGLError("Check error after set up initial program")
// Initialize textures
glGenTextures(4, textureArray_);
for (unsigned int i = 0; i < 3; i++) {
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textureArray_[i]);
glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 16, GL_RGBA, width_, height_, GL_TRUE);
}
glBindTexture(GL_TEXTURE_2D, textureArray_[3]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width_, height_, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
mainTexture_ = textureArray_[0];
styleTexture_ = textureArray_[1];
featureTexture_ = textureArray_[2];
blankTexture_ = textureArray_[3];
// For texture compositing
listIndex_ = glGenLists(1);
glNewList(listIndex_, GL_COMPILE);
glBegin(GL_QUADS);
glMultiTexCoord2f(GL_TEXTURE1, 0, 0); glMultiTexCoord2f(GL_TEXTURE2, 0, 0); glVertex2i(0, 0);
glMultiTexCoord2f(GL_TEXTURE1, 1, 0); glMultiTexCoord2f(GL_TEXTURE2, 1, 0); glVertex2i(width_, 0);
glMultiTexCoord2f(GL_TEXTURE1, 1, 1); glMultiTexCoord2f(GL_TEXTURE2, 1, 1); glVertex2i(width_, height_);
glMultiTexCoord2f(GL_TEXTURE1, 0, 1); glMultiTexCoord2f(GL_TEXTURE2, 0, 1); glVertex2i(0, height_);
glEnd();
glEndList();
// For texture cleaning
rectDrawingIndex_ = glGenLists(1);
glNewList(rectDrawingIndex_, GL_COMPILE);
glBegin(GL_QUADS);
glVertex2i(0, 0);
glVertex2i(width_, 0);
glVertex2i(width_, height_);
glVertex2i(0, height_);
glEnd();
glEndList();
glMatrixLoadIdentityEXT(GL_PROJECTION);
glMatrixLoadIdentityEXT(GL_MODELVIEW);
glMatrixOrthoEXT(GL_MODELVIEW, 0, width_, 0, height_, -1, 1);
// Create frame buffer blit object
glGenFramebuffers(1, &frameBufferBlit_);
glBindFramebuffer(GL_FRAMEBUFFER, frameBufferBlit_);
// Create color buffer
glGenRenderbuffers(1, &colorBufferBlit_);
glBindRenderbuffer(GL_RENDERBUFFER, colorBufferBlit_);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, width_, height_);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorBufferBlit_);
glGenRenderbuffers(1, &depthBufferBlit_);
glBindRenderbuffer(GL_RENDERBUFFER, depthBufferBlit_);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width_, height_);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthBufferBlit_);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, depthBufferBlit_);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, blankTexture_, 0);
// -----------------------------------------------------------------------------------------------
// Create frame buffer object
glGenFramebuffers(1, &frameBuffer_);
glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer_);
// Create color buffer
glGenRenderbuffers(1, &colorBuffer_);
glBindRenderbuffer(GL_RENDERBUFFER, colorBuffer_);
glRenderbufferStorageMultisample(GL_RENDERBUFFER, 16, GL_RGBA8, width_, height_);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorBuffer_);
glGenRenderbuffers(1, &depthBuffer_);
glBindRenderbuffer(GL_RENDERBUFFER, depthBuffer_);
glRenderbufferStorageMultisample(GL_RENDERBUFFER, 16, GL_DEPTH24_STENCIL8, width_, height_);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthBuffer_);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, depthBuffer_);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, mainTexture_, 0);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status == GL_FRAMEBUFFER_COMPLETE) {
// You have succeeded!
glClearStencil(0);
glClearColor(0, 0, 0, 0); // White BG
glStencilMask(~0);
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_NOTEQUAL, 0, 0x1F);
glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
} else {
// You are all about failure.
switch(status){
case GL_FRAMEBUFFER_UNDEFINED:
fprintf(stderr, "GL_FRAMEBUFFER_UNDEFINED\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
fprintf(stderr, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
fprintf(stderr, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
fprintf(stderr, "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
fprintf(stderr, "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER\n");
break;
case GL_FRAMEBUFFER_UNSUPPORTED:
fprintf(stderr, "GL_FRAMEBUFFER_UNSUPPORTED\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
fprintf(stderr, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:
fprintf(stderr, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS\n");
break;
default:
fprintf(stderr, "else\n");
break;
}
exit(1);
}
// Set up background
boost::optional<color> const& bg = m.background();
if (bg) {
cleanTexture(mainTexture_, bg->red(), bg->green(), bg->blue(), bg->alpha());
//cleanTexture(featureTexture_, 255, 255, 255, 0);
}
// TODO: Background image
return true;
}
int main(int argc, char **argv)
{
GLenum status;
GLboolean hasDSA;
int samples = 0;
int i;
glutInitWindowSize(canvas_width, canvas_height);
glutInit(&argc, argv);
for (i=1; i<argc; i++) {
if (argv[i][0] == '-') {
int value = atoi(argv[i]+1);
if (value >= 1) {
samples = value;
continue;
}
}
fprintf(stderr, "usage: %s [-#]\n where # is the number of samples/pixel\n",
programName);
exit(1);
}
if (samples > 0) {
char buffer[200];
if (samples == 1)
samples = 0;
printf("requesting %d samples\n", samples);
sprintf(buffer, "rgb stencil~4 double samples~%d", samples);
glutInitDisplayString(buffer);
} else {
/* Request a double-buffered window with at least 4 stencil bits and
8 samples per pixel. */
glutInitDisplayString("rgb stencil~4 double samples~8");
}
glutCreateWindow("Classic PostScript tiger NV_path_rendering example");
printf("vendor: %s\n", glGetString(GL_VENDOR));
printf("version: %s\n", glGetString(GL_VERSION));
printf("renderer: %s\n", glGetString(GL_RENDERER));
printf("samples per pixel = %d\n", glutGet(GLUT_WINDOW_NUM_SAMPLES));
printf("Executable: %d bit\n", (int)8*sizeof(int*));
printf("\n");
printf("Use left mouse button to scale/zoom (vertical, up/down) and rotate (right=clockwise, left=ccw)\n");
printf("Rotate and zooming is centered where you first left mouse click\n");
printf("Hold down Ctrl at left mouse click to JUST SCALE\n");
printf("Hold down Shift at left mouse click to JUST ROTATE\n");
printf("\n");
printf("Use middle mouse button to slide (translate)\n");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
initModelAndViewMatrices();
glutCreateMenu(menu);
glutAddMenuEntry("[f] Toggle filling", 'f');
glutAddMenuEntry("[s] Toggle stroking", 's');
glutAddMenuEntry("[r] Reset view", 'r');
glutAddMenuEntry("[Esc] Quit", 27);
glutAttachMenu(GLUT_RIGHT_BUTTON);
status = glewInit();
if (status != GLEW_OK) {
fatalError("OpenGL Extension Wrangler (GLEW) failed to initialize");
}
hasDSA = glewIsSupported("GL_EXT_direct_state_access");
if (!hasDSA) {
fatalError("OpenGL implementation doesn't support GL_EXT_direct_state_access (you should be using NVIDIA GPUs...)");
}
initializeNVPR(programName);
if (!has_NV_path_rendering) {
fatalError("required NV_path_rendering OpenGL extension is not present");
}
initGraphics();
path_count = getTigerPathCount();
glutMainLoop();
return 0;
}
int
main(int argc, char **argv)
{
GLenum status;
GLboolean hasDSA;
int samples = 0;
int i;
glutInitWindowSize(640, 480);
glutInit(&argc, argv);
for (i=1; i<argc; i++) {
if (argv[i][0] == '-') {
int value = atoi(argv[i]+1);
if (value >= 1) {
samples = value;
continue;
}
}
fprintf(stderr, "usage: %s [-#]\n where # is the number of samples/pixel\n",
programName);
exit(1);
}
if (samples > 0) {
char buffer[200];
if (samples == 1)
samples = 0;
printf("requesting %d samples\n", samples);
sprintf(buffer, "rgb stencil~4 double samples~%d", samples);
glutInitDisplayString(buffer);
} else {
/* Request a double-buffered window with at least 4 stencil bits and
8 samples per pixel. */
glutInitDisplayString("rgb stencil~4 double samples~8");
}
if (!glutGet(GLUT_DISPLAY_MODE_POSSIBLE)) {
printf("fallback GLUT display config!\n");
glutInitDisplayString(NULL);
glutInitDisplayMode(GLUT_RGB | GLUT_ALPHA | GLUT_DOUBLE | GLUT_STENCIL);
}
glutCreateWindow("Welsh dragon NV_path_rendering example");
printf("vendor: %s\n", glGetString(GL_VENDOR));
printf("version: %s\n", glGetString(GL_VERSION));
printf("renderer: %s\n", glGetString(GL_RENDERER));
printf("samples = %d\n", glutGet(GLUT_WINDOW_NUM_SAMPLES));
printf("Executable: %d bit\n", (int)(8*sizeof(int*)));
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
status = glewInit();
if (status != GLEW_OK) {
fatalError("OpenGL Extension Wrangler (GLEW) failed to initialize");
}
// Use glutExtensionSupported because glewIsSupported is unreliable for DSA.
hasDSA = glutExtensionSupported("GL_EXT_direct_state_access");
if (!hasDSA) {
fatalError("OpenGL implementation doesn't support GL_EXT_direct_state_access (you should be using NVIDIA GPUs...)");
}
initializeNVPR(programName);
if (!has_NV_path_rendering) {
fatalError("required NV_path_rendering OpenGL extension is not present");
}
initGraphics();
glutMainLoop();
return 0;
}
