resueltos - vectores y matrices en c++

¿Cuál es la forma más rápida de dibujar una matriz 2D de tríos de colores en la pantalla?

Question

El idioma de destino es C / C ++ y el programa solo debe funcionar en Linux, pero obviamente se prefieren las soluciones independientes de plataforma. Ejecuto Xorg, XVideo y OpenGL están disponibles.

¿Cuántos FPS puedo esperar en 1024x768 en un Intel Core 2 Duo con gráficos Intel? (SÓLO el recuento de dibujos considera que los arreglos están listos en la RAM, no se necesita un pronóstico preciso)

Answer 1

¿Cuántos FPS puedo esperar en 1024x768?

La respuesta a esa pregunta depende de tantos factores que es imposible decir.

Answer 2

La manera más rápida de dibujar una matriz 2D de tríos de colores:

1. Utilice el almacenamiento flotante ( no de bytes, no doble). Cada triplete consiste en 3 flotadores de 0.0 a 1.0 cada uno. Este es el formato implementado de manera óptima por las GPU (pero utilice el almacenamiento GL_LUMINANCE escala de grises cuando no necesite matiz, ¡mucho más rápido!)
2. Suba la matriz a una textura con glTexImage2D
3. Asegúrese de que el parámetro de textura GL_TEXTURE_MIN_FILTER esté establecido en GL_NEAREST
4. Asigna la textura a un quad apropiado.

Este método es un poco más rápido que glDrawPixels (que por alguna razón tiende a estar mal implementado) y mucho más rápido que usar el blitting nativo de la plataforma.

Además, le ofrece la opción de repetir repetidamente el paso 4 sin el paso 2 cuando su mapa de píxeles no haya cambiado, lo que por supuesto es mucho más rápido.

Las bibliotecas que proporcionan solo blitting nativo lento incluyen:

• GDI de Windows
• SDL en X11 (en Windows proporciona un backend opengl rápido cuando usa HW_SURFACE)
• Qt

En cuanto al FPS, puede obtener una textura de 1024x768 en un Intel Core 2 Duo con gráficos Intel: aproximadamente 60FPS si la textura cambia cada fotograma y> 100FPS si no lo hace.

Pero solo hágalo usted mismo y vea;)

Answer 3

Lo hice hace un tiempo usando C y OpenGL, y obtuve un muy buen rendimiento al crear un quad de pantalla completa, y luego uso el mapeo de texturas para transferir el mapa de bits a la superficie del quad.

Aquí hay un código de ejemplo, espero que pueda hacer uso de él.

#include <GL/glut.h>
#include <GL/glut.h>

#define WIDTH 1024
#define HEIGHT 768

unsigned char texture[WIDTH][HEIGHT][3];             

void renderScene() {    

    // render the texture here

    glEnable (GL_TEXTURE_2D);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    glTexImage2D (
        GL_TEXTURE_2D,
        0,
        GL_RGB,
        WIDTH,
        HEIGHT,
        0,
        GL_RGB,
        GL_UNSIGNED_BYTE,
        &texture[0][0][0]
    );

    glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f); glVertex2f(-1.0, -1.0);
        glTexCoord2f(1.0f, 0.0f); glVertex2f( 1.0, -1.0);
        glTexCoord2f(1.0f, 1.0f); glVertex2f( 1.0,  1.0);
        glTexCoord2f(0.0f, 1.0f); glVertex2f(-1.0,  1.0);
    glEnd();

    glFlush();
    glutSwapBuffers();
}

int main(int argc, char **argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

    glutInitWindowPosition(100, 100);
    glutInitWindowSize(WIDTH, HEIGHT);
    glutCreateWindow(" ");

    glutDisplayFunc(renderScene);

    glutMainLoop();

    return 0;
}

Answer 4

Otras opciones aparte de SDL (como se mencionó)

• El Cairo emerge con brillo (en C, funciona en todos los planos pero es mejor en Linux)
• QT Canvas (en C ++, multiplaforma)
• OpenGL raw API o QT OpenGL (necesita saber openGL)
• Xlib / XCB puro si desea tener en cuenta las plataformas no abiertas

Mi sugerencia

1. QT si prefieres C ++
2. El Cairo si prefiere C

Answer 5

Si está intentando volcar píxeles a la pantalla, probablemente quiera utilizar la faulilidad ''superficial'' de sdl. Para obtener el máximo rendimiento, intente organizar los datos de entrada en un diseño similar a la superficie de salida. Si es posible, manténgase alejado de la configuración de píxeles en la superficie, uno por uno.

SDL no es una interfaz de hardware en sí misma, sino una capa de portabilidad que funciona bien sobre muchas otras capas de visualización, incluidas DirectX, OpenGL, DirectFB y xlib, por lo que se obtiene una muy buena portabilidad, y es una capa muy delgada Además de esas tecnologías, usted paga muy poco sobrecarga de rendimiento además de esas.

Answer 6

la pregunta "¿cuántos fps puedo esperar?" no puede responderse seriamente. ni siquiera si nombra al abuelo del tipo que hizo el diseño del procesador. depende de tooooo muchas variables.

• ¿Cuántos trillizos necesitas renderizar?
• cambian entre los marcos?
• ¿a qué velocidad (no notará el cambio si es más de 30 veces por segundo)?
• ¿todos los píxeles cambian todo el tiempo o solo algunos de los píxeles en algunas áreas?
• ¿miras los píxeles sin distorsión de perspectiva?
• ¿siempre ves todos los píxeles?
• Dependiendo de la versión del controlador OpenGL obtendrá diferentes resultados

esto podría continuar para siempre, la respuesta depende absolutamente de su algoritmo. si te apegas al enfoque opengl, también podrías probar diferentes extensiones (por ejemplo, http://www.opengl.org/registry/specs/NV/pixel_data_range.txt ), para ver si se ajusta mejor a tus necesidades; aunque el método glTexSubImage () ya mencionado es bastante rápido.