Pantalla de píxeles en la pantalla en C

Question

¿Cómo cambiaría un píxel en una pantalla, en C?

No asuma NADA: Estoy usando una máquina linux desde la consola para hacer esto. No quiero utilizar toolkits o marcos de GUI para dibujar el píxel. No quiero dibujar el pixel en una ventana. Quiero dibujar el pixel directamente a la pantalla.

EDITAR: Tengo una pantalla. Estoy en una computadora portátil ejecutando Linux desde la consola. Preferiría una solución que no utiliza X ya que prefiero aprender cómo funciona X que cómo usar X.

Si hay más información, pregunte, pero no asuma. No estoy tratando de construir una GUI, y ese fue el principal propósito de bloquear las suposiciones ya que no quiero que la gente suponga que estoy haciendo las cosas a la larga cuando en realidad solo estoy retocando.

EDIT 2: Puede usar cualquier biblioteca relacionada con X11, siempre que pueda explicar cómo funcionan.

Answer 1

Si realmente no asumimos nada, ¿podemos siquiera asumir que X se está ejecutando? Para el caso, ¿podemos siquiera asumir que hay una tarjeta de video? Quizás Linux se está ejecutando sin cabeza y estamos accediendo a él a través de una consola en serie.

Si se nos permite asumir algunas cosas, supongamos que Linux se ha iniciado con soporte de framebuffer. (Han pasado un par de años desde que trabajé con los framebuffers de Linux, puedo obtener algunos de los detalles incorrectos.) Habrá un dispositivo creado, probablemente /dev/fb o /dev/fb0. Abra ese archivo y comience a escribir valores RGB en un desplazamiento, y la pantalla cambiará, prácticamente sin importar nada: consola de texto, consola gráfica, entorno de escritorio completo, etc. Si desea ver si el soporte de framebuffer funciona, haga dd if=/dev/zero of=/dev/fb en la línea de comandos, y la pantalla debe ir completamente negra.

Answer 2

C no tiene ninguna capacidad de gráficos; necesitará utilizar una biblioteca de terceros para esto.

Answer 3

No puede suponer una pantalla en C. Literalmente no hay manera de hacer lo que pide.

Editar: De acuerdo, tiene una pantalla, pero una vez más, no hay mucho que pueda obtener desde allí. El punto es que hay una TONELADA de estándares competitivos para pantallas gráficas, y aunque algunos de ellos (interfaces VGA, por ejemplo) están estandarizados, muchos de los otros (interfaces de controlador de pantalla, por ejemplo) NO lo son. Mucho de lo que X (y otros controladores de dispositivos de visualización, como Windows o similares) tienen, tiene un código de interfaz específico para saber cómo hablar con los controladores de pantalla; resumen la complejidad de tratar con los controladores de pantalla. Los sistemas de ventanas, sin embargo, tienen GRANDES bibliotecas de código complicado y específico para tratar con los controladores de pantalla; el hecho de que estas cosas sean relativamente transparentes es una indicación de cuánto trabajo han dedicado a estas cosas con el tiempo.

Answer 4

Creo que lo que está buscando es información sobre cómo escribir en el búfer de cuadros. La forma más fácil sería usar SDL y renderizar en el búfer de trama, o bien usar GTK + con DirectFB, aunque eso va en contra de su edicto de no usar toolkits o frameworks.

Answer 5

muy primitiva y hacer muchas suposiciones:

fd = open("/dev/fb0", O_RDWR); 
lseek(fd, 640*y+x, SEEK_SET); 
write(fd, "\377\377\377\377", 4); 

En realidad, se podría utilizar en lugar de mmapwrite, y el uso apropiado del ioctl para consultar el modo de pantalla en lugar de asumir 640xHHH 32 bpp. También hay problemas endian, etc.

Así que en la realidad real, puede usar algún tipo de código de biblioteca que maneje este tipo de cosas para usted.

Answer 6

Supongo que podría pintar en el programa de terminal que está utilizando como su consola. Todo lo que tienes que hacer es descubrir cuál es y buscarlo.

Whoops Supuse una terminal. : P

Answer 7

Su mejor amigo sería printf. La cuadrícula impresa básicamente con algún símbolo (como '.') Significaría que todos los píxeles están activados. Y una cuadrícula impresa con un carácter de espacio en blanco (como '') significaría que todos los píxeles están apagados. Por ejemplo, esto es lo que podemos llamar la sine() función de flujo de salida normal:

#include <stdio.h> 

#define MAXY 20 
#define MAXX 75 
static char display[MAXY][MAXX]; 

void setGraph(void) { 
    memset(display, ' ', sizeof(display)); 

    int i; 
    // draw Y axis 
    for (i=0; i < MAXY; i++) 
     display[i][3] = '|'; 
    // draw X axis 
    for (i=0; i < MAXX; i++) 
     display[1][i] = '-'; 
    // draw origin 
    display[0][0] = '0'; 
    display[0][1] = ','; 
    display[0][2] = '0'; 
    // draw arrows 
    display[1][MAXX-1] = '>'; 
    display[MAXY-1][3] = 'v'; 
    // draw labels 
    display[0][MAXX-3] = 'X'; 
    display[MAXY-3][2] = 'Y'; 
} 

void plotSine() { 
    int i; 
    int y; 
    for (i=4; i < MAXX; i++) { 
     y = 2 + (int)7.0*(1.0 + sin(0.45*(float)i)); 
     display[y][i] = '.'; 
    } 
} 

void drawDisplay(void) { 
    int x,y; 
    for (x=0; x < MAXY; x++) { 
     for (y=0; y < MAXX; y++) { 
     printf("%c", display[x][y]); 
     } 
     printf("\n"); 
    } 
} 

int main() { 
    setGraph(); 
    plotSine(); 
    drawDisplay(); 
    return 0; 
} 

que generará tales salida:

0,0|                 X 
--------------------------------------------------------------------------> 
    |  **   **   **   **   ** 
    |  * *   * *   * *   * *   * * 
    | 
    | *    *    *    *    * 
    |   *    *    *    *    * 
    | 
    | *    *    *    *    * 
    |   *    *    *    *    * 
    | 
    | *    *    *    *    * 
    |   *    *    *    *    * 
    | 
    | *   * *   * *   * *   * *   * 
    |*   **   **   **   **   ** 
    | 
    Y| 
    | 
    v