Как использовать GLUT/OpenGL для рендеринга в файл?

Ответ 1

Вы почти наверняка не хотите GLUT, независимо. Ваши требования не соответствуют тому, что он намеревался сделать (и даже если ваши требования соответствуют его намеченной цели, вы, как правило, этого не хотите).

Вы можете использовать OpenGL. Чтобы генерировать вывод в файле, вы в основном настраиваете OpenGL для рендеринга текстуры, а затем читаете полученную текстуру в основной памяти и сохраняете ее в файле. По крайней мере, на некоторых системах (например, в Windows), я уверен, что вам все равно придется создавать окно и ассоциировать контекст рендеринга с окном, хотя, вероятно, это будет хорошо, если окно всегда скрыто.

Ответ 2

glReadPixels пример работающего PBO

В приведенном ниже примере создается либо:

• один промилле на кадр при 200 кадрах в секунду и без дополнительных зависимостей,
• один png на кадр при 600 FPS с libpng
• одна миль на галлон для всех кадров при 1200 FPS с FFmpeg

на ramfs. Чем лучше сжатие, тем больше FPS, поэтому мы должны быть связаны с вводом-выводом памяти.

FPS больше 200 на моем 60 FPS экране, и все изображения разные, поэтому я уверен, что он не ограничен FPS экрана.

GIF в этом ответе был сгенерирован из видео, как объяснено на: https://askubuntu.com/questions/648603/how-to-create-an-animated-gif-from-mp4-video-via-command-line/837574#837574

glReadPixels - это ключевая функция OpenGL, которая считывает пиксели с экрана. Также взгляните на настройки в init().

glReadPixels сначала читает нижнюю строку пикселей, в отличие от большинства форматов изображений, поэтому обычно требуется преобразование.

#ifndef PPM
#define PPM 1
#endif
#ifndef LIBPNG
#define LIBPNG 1
#endif
#ifndef FFMPEG
#define FFMPEG 1
#endif

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define GL_GLEXT_PROTOTYPES 1
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <GL/glext.h>

#if LIBPNG
#include <png.h>
#endif

#if FFMPEG
#include <libavcodec/avcodec.h>
#include <libavutil/imgutils.h>
#include <libavutil/opt.h>
#include <libswscale/swscale.h>
#endif

enum Constants { SCREENSHOT_MAX_FILENAME = 256 };
static GLubyte *pixels = NULL;
static GLuint fbo;
static GLuint rbo_color;
static GLuint rbo_depth;
static int offscreen = 1;
static unsigned int max_nframes = 128;
static unsigned int nframes = 0;
static unsigned int time0;
static unsigned int height = 128;
static unsigned int width = 128;
#define PPM_BIT (1 << 0)
#define LIBPNG_BIT (1 << 1)
#define FFMPEG_BIT (1 << 2)
static unsigned int output_formats = PPM_BIT | LIBPNG_BIT | FFMPEG_BIT;

/* Model. */
static double angle;
static double delta_angle;

#if PPM
/* Take screenshot with glReadPixels and save to a file in PPM format.
 *
 * -   filename: file path to save to, without extension
 * -   width: screen width in pixels
 * -   height: screen height in pixels
 * -   pixels: intermediate buffer to avoid repeated mallocs across multiple calls.
 *     Contents of this buffer do not matter. May be NULL, in which case it is initialized.
 *     You must 'free' it when you won't be calling this function anymore.
 */
static void screenshot_ppm(const char *filename, unsigned int width,
        unsigned int height, GLubyte **pixels) {
    size_t i, j, cur;
    const size_t format_nchannels = 3;
    FILE *f = fopen(filename, "w");
    fprintf(f, "P3\n%d %d\n%d\n", width, height, 255);
    *pixels = realloc(*pixels, format_nchannels * sizeof(GLubyte) * width * height);
    glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, *pixels);
    for (i = 0; i < height; i++) {
        for (j = 0; j < width; j++) {
            cur = format_nchannels * ((height - i - 1) * width + j);
            fprintf(f, "%3d %3d %3d ", (*pixels)[cur], (*pixels)[cur + 1], (*pixels)[cur + 2]);
        }
        fprintf(f, "\n");
    }
    fclose(f);
}
#endif

#if LIBPNG
/* Adapted from https://github.com/cirosantilli/cpp-cheat/blob/19044698f91fefa9cb75328c44f7a487d336b541/png/open_manipulate_write.c */
static png_byte *png_bytes = NULL;
static png_byte **png_rows = NULL;
static void screenshot_png(const char *filename, unsigned int width, unsigned int height,
        GLubyte **pixels, png_byte **png_bytes, png_byte ***png_rows) {
    size_t i, nvals;
    const size_t format_nchannels = 4;
    FILE *f = fopen(filename, "wb");
    nvals = format_nchannels * width * height;
    *pixels = realloc(*pixels, nvals * sizeof(GLubyte));
    *png_bytes = realloc(*png_bytes, nvals * sizeof(png_byte));
    *png_rows = realloc(*png_rows, height * sizeof(png_byte*));
    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, *pixels);
    for (i = 0; i < nvals; i++)
        (*png_bytes)[i] = (*pixels)[i];
    for (i = 0; i < height; i++)
        (*png_rows)[height - i - 1] = &(*png_bytes)[i * width * format_nchannels];
    png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    if (!png) abort();
    png_infop info = png_create_info_struct(png);
    if (!info) abort();
    if (setjmp(png_jmpbuf(png))) abort();
    png_init_io(png, f);
    png_set_IHDR(
        png,
        info,
        width,
        height,
        8,
        PNG_COLOR_TYPE_RGBA,
        PNG_INTERLACE_NONE,
        PNG_COMPRESSION_TYPE_DEFAULT,
        PNG_FILTER_TYPE_DEFAULT
    );
    png_write_info(png, info);
    png_write_image(png, *png_rows);
    png_write_end(png, NULL);
    png_destroy_write_struct(&png, &info);
    fclose(f);
}
#endif

#if FFMPEG
/* Adapted from: https://github.com/cirosantilli/cpp-cheat/blob/19044698f91fefa9cb75328c44f7a487d336b541/ffmpeg/encode.c */

static AVCodecContext *c = NULL;
static AVFrame *frame;
static AVPacket pkt;
static FILE *file;
static struct SwsContext *sws_context = NULL;
static uint8_t *rgb = NULL;

static void ffmpeg_encoder_set_frame_yuv_from_rgb(uint8_t *rgb) {
    const int in_linesize[1] = { 4 * c->width };
    sws_context = sws_getCachedContext(sws_context,
            c->width, c->height, AV_PIX_FMT_RGB32,
            c->width, c->height, AV_PIX_FMT_YUV420P,
            0, NULL, NULL, NULL);
    sws_scale(sws_context, (const uint8_t * const *)&rgb, in_linesize, 0,
            c->height, frame->data, frame->linesize);
}

void ffmpeg_encoder_start(const char *filename, int codec_id, int fps, int width, int height) {
    AVCodec *codec;
    int ret;
    avcodec_register_all();
    codec = avcodec_find_encoder(codec_id);
    if (!codec) {
        fprintf(stderr, "Codec not found\n");
        exit(1);
    }
    c = avcodec_alloc_context3(codec);
    if (!c) {
        fprintf(stderr, "Could not allocate video codec context\n");
        exit(1);
    }
    c->bit_rate = 400000;
    c->width = width;
    c->height = height;
    c->time_base.num = 1;
    c->time_base.den = fps;
    c->gop_size = 10;
    c->max_b_frames = 1;
    c->pix_fmt = AV_PIX_FMT_YUV420P;
    if (codec_id == AV_CODEC_ID_H264)
        av_opt_set(c->priv_data, "preset", "slow", 0);
    if (avcodec_open2(c, codec, NULL) < 0) {
        fprintf(stderr, "Could not open codec\n");
        exit(1);
    }
    file = fopen(filename, "wb");
    if (!file) {
        fprintf(stderr, "Could not open %s\n", filename);
        exit(1);
    }
    frame = av_frame_alloc();
    if (!frame) {
        fprintf(stderr, "Could not allocate video frame\n");
        exit(1);
    }
    frame->format = c->pix_fmt;
    frame->width  = c->width;
    frame->height = c->height;
    ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height, c->pix_fmt, 32);
    if (ret < 0) {
        fprintf(stderr, "Could not allocate raw picture buffer\n");
        exit(1);
    }
}

void ffmpeg_encoder_finish(void) {
    uint8_t endcode[] = { 0, 0, 1, 0xb7 };
    int got_output, ret;
    do {
        fflush(stdout);
        ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
        if (ret < 0) {
            fprintf(stderr, "Error encoding frame\n");
            exit(1);
        }
        if (got_output) {
            fwrite(pkt.data, 1, pkt.size, file);
            av_packet_unref(&pkt);
        }
    } while (got_output);
    fwrite(endcode, 1, sizeof(endcode), file);
    fclose(file);
    avcodec_close(c);
    av_free(c);
    av_freep(&frame->data[0]);
    av_frame_free(&frame);
}

void ffmpeg_encoder_encode_frame(uint8_t *rgb) {
    int ret, got_output;
    ffmpeg_encoder_set_frame_yuv_from_rgb(rgb);
    av_init_packet(&pkt);
    pkt.data = NULL;
    pkt.size = 0;
    ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
    if (ret < 0) {
        fprintf(stderr, "Error encoding frame\n");
        exit(1);
    }
    if (got_output) {
        fwrite(pkt.data, 1, pkt.size, file);
        av_packet_unref(&pkt);
    }
}

void ffmpeg_encoder_glread_rgb(uint8_t **rgb, GLubyte **pixels, unsigned int width, unsigned int height) {
    size_t i, j, k, cur_gl, cur_rgb, nvals;
    const size_t format_nchannels = 4;
    nvals = format_nchannels * width * height;
    *pixels = realloc(*pixels, nvals * sizeof(GLubyte));
    *rgb = realloc(*rgb, nvals * sizeof(uint8_t));
    /* Get RGBA to align to 32 bits instead of just 24 for RGB. May be faster for FFmpeg. */
    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, *pixels);
    for (i = 0; i < height; i++) {
        for (j = 0; j < width; j++) {
            cur_gl  = format_nchannels * (width * (height - i - 1) + j);
            cur_rgb = format_nchannels * (width * i + j);
            for (k = 0; k < format_nchannels; k++)
                (*rgb)[cur_rgb + k] = (*pixels)[cur_gl + k];
        }
    }
}
#endif

static void model_init(void) {
    angle = 0;
    delta_angle = 1;
}

static int model_update(void) {
    angle += delta_angle;
    return 0;
}

static int model_finished(void) {
    return nframes >= max_nframes;
}

static void init(void)  {
    int glget;

    if (offscreen) {
        /*  Framebuffer */
        glGenFramebuffers(1, &fbo);
        glBindFramebuffer(GL_FRAMEBUFFER, fbo);

        /* Color renderbuffer. */
        glGenRenderbuffers(1, &rbo_color);
        glBindRenderbuffer(GL_RENDERBUFFER, rbo_color);
        /* Storage must be one of: */
        /* GL_RGBA4, GL_RGB565, GL_RGB5_A1, GL_DEPTH_COMPONENT16, GL_STENCIL_INDEX8. */
        glRenderbufferStorage(GL_RENDERBUFFER, GL_RGB565, width, height);
        glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo_color);

        /* Depth renderbuffer. */
        glGenRenderbuffers(1, &rbo_depth);
        glBindRenderbuffer(GL_RENDERBUFFER, rbo_depth);
        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
        glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rbo_depth);

        glReadBuffer(GL_COLOR_ATTACHMENT0);

        /* Sanity check. */
        assert(glCheckFramebufferStatus(GL_FRAMEBUFFER));
        glGetIntegerv(GL_MAX_RENDERBUFFER_SIZE, &glget);
        assert(width < (unsigned int)glget);
        assert(height < (unsigned int)glget);
    } else {
        glReadBuffer(GL_BACK);
    }

    glClearColor(0.0, 0.0, 0.0, 0.0);
    glEnable(GL_DEPTH_TEST);
    glPixelStorei(GL_PACK_ALIGNMENT, 1);
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);

    time0 = glutGet(GLUT_ELAPSED_TIME);
    model_init();
#if FFMPEG
    ffmpeg_encoder_start("tmp.mpg", AV_CODEC_ID_MPEG1VIDEO, 25, width, height);
#endif
}

static void deinit(void)  {
    printf("FPS = %f\n", 1000.0 * nframes / (double)(glutGet(GLUT_ELAPSED_TIME) - time0));
    free(pixels);
#if LIBPNG
    if (output_formats & LIBPNG_BIT) {
        free(png_bytes);
        free(png_rows);
    }
#endif
#if FFMPEG
    if (output_formats & FFMPEG_BIT) {
        ffmpeg_encoder_finish();
        free(rgb);
    }
#endif
    if (offscreen) {
        glDeleteFramebuffers(1, &fbo);
        glDeleteRenderbuffers(1, &rbo_color);
        glDeleteRenderbuffers(1, &rbo_depth);
    }
}

static void draw_scene(void) {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    glRotatef(angle, 0.0f, 0.0f, -1.0f);
    glBegin(GL_TRIANGLES);
    glColor3f(1.0f, 0.0f, 0.0f);
    glVertex3f( 0.0f,  0.5f, 0.0f);
    glColor3f(0.0f, 1.0f, 0.0f);
    glVertex3f(-0.5f, -0.5f, 0.0f);
    glColor3f(0.0f, 0.0f, 1.0f);
    glVertex3f( 0.5f, -0.5f, 0.0f);
    glEnd();
}

static void display(void) {
    char filename[SCREENSHOT_MAX_FILENAME];
    draw_scene();
    if (offscreen) {
        glFlush();
    } else {
        glutSwapBuffers();
    }
#if PPM
    if (output_formats & PPM_BIT) {
        snprintf(filename, SCREENSHOT_MAX_FILENAME, "tmp.%d.ppm", nframes);
        screenshot_ppm(filename, width, height, &pixels);
    }
#endif
#if LIBPNG
    if (output_formats & LIBPNG_BIT) {
        snprintf(filename, SCREENSHOT_MAX_FILENAME, "tmp.%d.png", nframes);
        screenshot_png(filename, width, height, &pixels, &png_bytes, &png_rows);
    }
#endif
# if FFMPEG
    if (output_formats & FFMPEG_BIT) {
        frame->pts = nframes;
        ffmpeg_encoder_glread_rgb(&rgb, &pixels, width, height);
        ffmpeg_encoder_encode_frame(rgb);
    }
#endif
    nframes++;
    if (model_finished())
        exit(EXIT_SUCCESS);
}

static void idle(void) {
    while (model_update());
    glutPostRedisplay();
}

int main(int argc, char **argv) {
    int arg;
    GLint glut_display;

    /* CLI args. */
    glutInit(&argc, argv);
    arg = 1;
    if (argc > arg) {
        offscreen = (argv[arg][0] == '1');
    } else {
        offscreen = 1;
    }
    arg++;
    if (argc > arg) {
        max_nframes = strtoumax(argv[arg], NULL, 10);
    }
    arg++;
    if (argc > arg) {
        width = strtoumax(argv[arg], NULL, 10);
    }
    arg++;
    if (argc > arg) {
        height = strtoumax(argv[arg], NULL, 10);
    }
    arg++;
    if (argc > arg) {
        output_formats = strtoumax(argv[arg], NULL, 10);
    }

    /* Work. */
    if (offscreen) {
        /* TODO: if we use anything smaller than the window, it only renders a smaller version of things. */
        /*glutInitWindowSize(50, 50);*/
        glutInitWindowSize(width, height);
        glut_display = GLUT_SINGLE;
    } else {
        glutInitWindowSize(width, height);
        glutInitWindowPosition(100, 100);
        glut_display = GLUT_DOUBLE;
    }
    glutInitDisplayMode(glut_display | GLUT_RGBA | GLUT_DEPTH);
    glutCreateWindow(argv[0]);
    if (offscreen) {
        /* TODO: if we hide the window the program blocks. */
        /*glutHideWindow();*/
    }
    init();
    glutDisplayFunc(display);
    glutIdleFunc(idle);
    atexit(deinit);
    glutMainLoop();
    return EXIT_SUCCESS;
}

На GitHub.

Компилировать с:

sudo apt-get install libpng-dev libavcodec-dev libavutil-dev
gcc -DPPM=1 -DLIBPNG=1 -DFFMPEG=1 -ggdb3 -std=c99 -O0 -Wall -Wextra \
  -o offscreen offscreen.c -lGL -lGLU -lglut -lpng -lavcodec -lswscale -lavutil

Запуск 10 кадров "за кадром" (в основном TODO, работает, но не имеет преимуществ) с размером 200 x 100 и всеми выходными форматами:

./offscreen 1 10 200 100 7

Формат CLI:

./offscreen [offscreen [nframes [width [height [output_formats]]]]]

и output_formats - битовая маска:

ppm >> 0 | png >> 1 | mpeg >> 2

Запуск на экране (также не ограничивает мой FPS):

./offscreen 0

Сравнительный тест на Ubuntu 15.10, OpenGL 4.4.0, NVIDIA 352.63, Lenovo Thinkpad T430.

Также протестировано на Ubuntu 18.04, OpenGL 4.6.0 NVIDIA 390.77, Lenovo Thinkpad P51.

TODO: найдите способ сделать это на компьютере без графического интерфейса (например, X11). Кажется, что OpenGL просто не предназначен для рендеринга за пределами экрана, и что чтение пикселей обратно в GPU реализовано на интерфейсе с оконной системой (например, GLX). Смотрите: OpenGL без X.org в Linux

TODO: используйте окно 1x1, сделайте его неизменяемым и скройте его, чтобы сделать его более надежным. Если я сделаю любой из них, рендеринг не удастся, см. комментарии кода. Предотвращение изменения размера кажется невозможным в Glut, но GLFW поддерживает это. В любом случае, это не имеет большого значения, так как мой FPS не ограничен частотой обновления экрана, даже когда offscreen выключен.

Другие варианты, кроме PBO

• рендеринг в буферный буфер (место рендеринга по умолчанию)
• сделать текстуру
• рендеринг объекта Pixelbuffer (PBO)

Framebuffer и Pixelbuffer лучше, чем backbuffer и texture, поскольку они созданы для того, чтобы данные считывались обратно в CPU, тогда как backbuffer и текстуры сделаны так, чтобы они оставались на GPU и отображались на экране.

PBO предназначен для асинхронных передач, поэтому я думаю, что нам это не нужно, см. В чем различия между объектом Frame Buffer и объектом Pixel Buffer в OpenGL?,

Возможно, закадровую Мезу стоит изучить: http://www.mesa3d.org/osmesa.html

apiretrace

https://github.com/apitrace/apitrace

Просто работает, и не требует от вас никакого изменения кода:

git clone https://github.com/apitrace/apitrace
cd apitrace
git checkout 7.0
mkdir build
cd build
cmake ..
make
# Creates opengl_executable.out.trace
./apitrace trace /path/to/opengl_executable.out
./apitrace dump-images opengl_executable.out.trace

Также доступно в Ubuntu 18.10 с:

 sudo apt-get install apitrace

Теперь у вас есть несколько скриншотов с именем:

animation.out.<n>.png

TODO: принцип работы.

Документы также предлагают это для видео:

apitrace dump-images -o - application.trace \
  | ffmpeg -r 30 -f image2pipe -vcodec ppm -i pipe: -vcodec mpeg4 -y output.mp4

Смотрите также:

• изображения в GIF: https://unix.stackexchange.com/questions/24014/creating-a-gif-animation-from-png-files/489210#489210
• изображения к видео: Как создать видео из изображений с помощью FFmpeg?

Vulkan

Похоже, что Vulkan разработан для поддержки закадрового рендеринга лучше, чем OpenGL.

Это упоминается в обзоре NVIDIA: https://developer.nvidia.com/transitioning-opengl-vulkan

Вот пример: https://github.com/SaschaWillems/Vulkan/blob/0616eeff4e697e4cd23cb9c97f5dd83afb79d908/offscreen/offscreen.cpp, но мне пока не удалось запустить Vulkan. 1 клок :-)

Связанный: Возможно ли выполнять внеэкранный рендеринг без Surface в Vulkan?

Сохранение изображения на холсте WebGL +

Это в основном игрушка из-за производительности, но она работает для действительно базовых сценариев использования:

• демо: https://cirosantilli.com#webgl
• Источник: https://github.com/cirosantilli/cirosantilli.github.io/blame/fab7f46ec85a5357170a1bee9b3b0580bde6bd88/README.adoc#L2083
• библиография: как сохранить холст как изображение png?

Библиография

• Как использовать GLUT/OpenGL для рендеринга в файл?
• Как сделать скриншот в OpenGL
• Как визуализировать вне экрана в OpenGL?
• glReadPixels() " данные " использование аргумента?
• Визуализация OpenGL ES 2.0 для изображения
• http://www.songho.ca/opengl/gl_fbo.html
• http://www.mesa3d.org/brianp/sig97/offscrn.htm
• Отрисовка вне экрана (с FBO и RenderBuffer) и передача цвета, глубины, трафарета в пикселях
• https://gamedev.stackexchange.com/questions/59204/opengl-fbo-render-off-screen-and-texture
• Каковы различия между объектом Frame Buffer и объектом Pixel Buffer в OpenGL?
• glReadPixels() " данные " использование аргумента?

FBO больше окна:

• OpenGL, как создать и визуализировать фрейм-буфер, который больше окна?
• FBO больше, чем размер экрана. Что я делаю не так?
• Renderbuffers больше, чем размер окна - OpenGL
• проблема сохранения OpenGL FBO больше, чем у окна

Нет окна /X11:

• OpenGL без X.org в Linux
• Можете ли вы создать контекст OpenGL, не открывая окно?
• Использование OpenGL без системы X-Window

Ответ 3

Не отвлекать от других отличных ответов, но если вы хотите, чтобы существующий пример мы делали Offscreen GL рендеринга в течение нескольких лет в OpenSCAD, как часть рендеринга тестовой Framework для .png файлов из командной строки. Соответствующие файлы находятся в https://github.com/openscad/openscad/tree/master/src в окне Offscreen *.cc

Он работает на OSX (CGL), Linux X11 (GLX), BSD (GLX) и Windows (WGL) с некоторыми причудами из-за различий в драйверах. Основной трюк заключается в том, чтобы забыть открыть окно (например, Дуглас Адамс говорит, что трюк для полета - это забыть попасть в землю). Он даже работает на "безголовом" linux/bsd, если у вас есть виртуальный сервер X11, работающий как Xvfb или Xvnc. Существует также возможность использовать программный рендеринг на Linux/BSD, установив переменную среды LIBGL_ALWAYS_SOFTWARE = ​​1 перед запуском вашей программы, что может помочь в некоторых ситуациях.

Это не единственная система для этого, я считаю, что система визуализации VTK делает что-то подобное.

Этот код немного устарел в своих методах (я разорвал код GLX из Brian Paul glxgears), особенно по мере появления новых систем, OSMesa, Mir, Wayland, EGL, Android, Vulkan и т.д., но обратите внимание на OffscreenXXX.cc имена файлов, где XXX - подсистема контекста GL, теоретически может быть перенесена на разные генераторы контекстов.

Ответ 4

Не уверен, что OpenGL - лучшее решение.
Но вы всегда можете отображать буфер вне экрана.

Типичным способом записи вывода openGL в файл является использование readPixels для копирования полученного пикселя пикселя сцены в файл изображения

Ответ 5

Вы можете использовать SFML http://www.sfml-dev.org/. Вы можете использовать класс изображения, чтобы сохранить результат рендеринга.

http://www.sfml-dev.org/documentation/1.6/classsf_1_1Image.htm

Чтобы получить визуализированный вывод, вы можете визуализировать текстуру или копировать экран.

Оказание текстуры:

• http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=36
• http://zavie.free.fr/opengl/index.html.en#rendertotexture

Копирование экрана:

• http://eonstrife.wordpress.com/2007/06/02/taking-a-screenshot-from-an-opengl-application/