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

Question

У меня есть программа, которая имитирует физическую систему, которая меняется со временем.Я хочу, чтобы через заданные интервалы (скажем, каждые 10 секунд) выводить визуализацию состояния симуляции в файл.Я хочу сделать это таким образом, чтобы было легко «выключить визуализацию» и вообще не выводить визуализацию.

Я смотрю на OpenGL и GLUT как на графические инструменты для визуализации.Однако проблема, похоже, заключается в том, что, во-первых, похоже, что он выводит только в окно и не может выводить в файл.Во-вторых, чтобы создать визуализацию, вы должны вызвать GLUTMainLoop, и это останавливает выполнение основной функции - единственными функциями, которые затем вызываются, являются вызовы из GUI.Однако я не хочу, чтобы это было приложение на основе графического интерфейса - я хочу, чтобы это было просто приложение, которое вы запускаете из командной строки, и оно генерирует серию изображений.Есть ли способ сделать это в GLUT / OpenGL?Или OpenGL - не тот инструмент для этого, и я должен использовать что-то еще

Answer 1

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

Пример ниже генерирует либо:

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

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

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;
}

On 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 просто не предназначен для рендеринга за пределами экрана, и что чтение пикселей обратно в графический процессор реализовано на интерфейсе с оконной системой (например, GLX ). См .: OpenGL без X.org в Linux

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

Другие опции, кроме PBO

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

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

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

Может быть, Mesa за кадром стоит изучить: 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?

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

• Как использовать GLUT / OpenGL для рендеринга в файл?
• Как сделать скриншот в OpenGL
• Как визуализировать вне экрана в OpenGL?
• glReadPixels () использование аргумента "data"?
• Визуализация 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
• Каковы различия между объектом буфера кадра и объектом буфера пикселя в OpenGL?
• Использование аргумента "data" glReadPixels ()?

FBO больше, чем окно:

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

Нет окна / X11:

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

Answer 2

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

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

Answer 3

Не для того, чтобы отказаться от других превосходных ответов, но если вы хотите существующий пример, мы уже несколько лет выполняем рендеринг Offscreen GL в OpenSCAD, как часть рендеринга Test 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.Существует также возможность использовать Software Rendering в Linux / BSD, установив переменную среды LIBGL_ALWAYS_SOFTWARE = ​​1 перед запуском вашей программы, что может помочь в некоторых ситуациях.

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

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

Answer 4

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

http://www.sfml -dev.org / документация / 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/

Answer 5

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

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