2012-09-11 19 views
11

In C++ utilizzando Code :: Blocks v10.05, come si disegna un singolo pixel sullo schermo della console? È così facile o sarebbe più semplice disegnare un rettangolo? Come posso colorarlo? Mi dispiace, ma non riesco a ottenere alcun codice da SOF, HF o persino cplusplus.com per funzionare. Questo è per una figura di Super Mario World sullo schermo. Il gioco penso sia a 16 bit, ed è per il sistema SNES. C :: B dice che ho bisogno dell'SDK per C :: B. Dice "afxwin.h" non esiste. Scarica forse? Questo è quello che sto cercando di fare:Pixel C++ nella finestra della console

Image I'm trying to create

+0

Puoi collegarti al codice che non potresti riuscire a lavorare? – Borgleader

+0

Wow, questo mi riporta indietro ... Le persone lo facevano in DOS. Dovevi saltare in memoria dove era stato memorizzato il set di caratteri e modificarlo (pratica comune per quasi tutto in DOS, compresi scrivere byte sulla scheda video in altre modalità grafiche), quindi disegnare i tuoi sprite usando i caratteri modificati. Ovviamente sei stato costretto a 256 possibili immagini secondarie. Non so se questo è ancora ciò che accade in Windows. Non posso dare una risposta, mi dispiace, tranne per dire che la finestra della console è solo un'altra finestra. Mi chiedo se è possibile agganciare il suo messaggio WM_PAINT. – paddy

+0

http://stackoverflow.com/questions/4576019/c-drawing-pixels-question – hCon

risposta

1

Console è un dispositivo di testo, in modo, in generale, non si scrive a singoli pixel. Puoi creare un font speciale e selezionarlo come font per console, ma sarà monocromatico. Ci sono librerie che semplificano la scrittura dell'interfaccia utente della console (ad esempio Curses), ma credo che tu abbia in mente anche più funzionalità di gioco oltre a mostrare semplicemente uno sprite.

se si desidera scrivere un gioco, suggerisco di dare un'occhiata ad alcuni framework/giochi/librerie di giochi, ad es. SDL

+0

Quindi dovrei visualizzare uno sprite/un'immagine nella finestra? Se sì, come lo faccio? – hCon

+0

Devi farlo per es. per la scuola, quindi è importante fare tutto il codice di modifica dei pixel o sei più interessato ai risultati? se precedente, quale ambiente usi (Win, Linux, etc - immagino Windows, basato su afxwin.h)? se quest'ultimo, ecco un tutorial: http://www.libsdl.org/intro.en/usingvideo.html –

16

Dipende dal sistema operativo. Suppongo che si sta programmando in una piattaforma Windows, quindi è possibile utilizzare SetPixel ma è necessario usare "windows.h" per ottenere un handle di console, ecco un esempio per disegnare le cos() funzione:

#include<windows.h> 
#include<iostream> 
#include <cmath> 

using namespace std; 

#define PI 3.14 

int main() 
{ 
    //Get a console handle 
    HWND myconsole = GetConsoleWindow(); 
    //Get a handle to device context 
    HDC mydc = GetDC(myconsole); 

    int pixel =0; 

    //Choose any color 
    COLORREF COLOR= RGB(255,255,255); 

    //Draw pixels 
    for(double i = 0; i < PI * 4; i += 0.05) 
    { 
     SetPixel(mydc,pixel,(int)(50+25*cos(i)),COLOR); 
     pixel+=1; 
    } 

    ReleaseDC(myconsole, mydc); 
    cin.ignore(); 
    return 0; 
} 

Puoi anche usare altre librerie come: conio.h allegro.h sdl, ecc.

+0

Gross: D Ma +1 per una "soluzione". Si noti che non si gestirà 'WM_PAINT' quindi se la regione non è valida, verrà cancellata. Windows normale è fortemente favorito da questo. – tenfour

+0

Codice :: Errore blocchi: 'GetConsoleWindow' non è stato dichiarato in questa soluzione. – hCon

+1

@Mike hai incluso l'intestazione "windows.h"? Ricorda che devi prenderlo da Microsoft. Devi scaricare microsoft sdk: http://www.microsoft.com/en-us/download/details.aspx?id=3138 – FacundoGFlores

10

Se vuoi rendere l'immagine un po 'blocca, puoi sfruttare i caratteri di blocco dello console code page.

  • = '\ xDB' = U + 2588 PIENO BLOCK
  • = '\ XDc' = U + 2584 metà inferiore BLOCK
  • = '\ Xdf' BLOCK = U + 2580 UPPER HALF
  • e lo spazio

utilizzando le mezze blocchi in combinazione con colored text, è possibile attivare una finestra di 80 × 25 console in un 80 × 50 16 display a colori. (Questo era l'approccio utilizzato dalla versione QBasic di Nibbles.)

Quindi, è sufficiente convertire l'immagine nella tavolozza a 16 colori e in una dimensione ragionevolmente piccola.

Mario in 8 lines and 10 columns of "text"

1

ho disegnato la linea retta utilizzando windows.h in Code :: Blocks. Non posso spiegarlo nei dettagli, ma posso fornirti un codice e una procedura per compilarlo in code :: blocks.

  1. andare al menu di impostazione e selezionare compilatore e debugger.
  2. Fare clic sulla scheda del linker e aggiungere una libreria di collegamenti libgdi32.a che si trova nella directory C: \ Programmi \ CodeBlocks \ MinGW \ lib.

Ora compilare questo programma

#include <windows.h> 

#include <cmath> 

#define ROUND(a) ((int) (a + 0.5)) 

/* set window handle */ 

static HWND sHwnd; 

static COLORREF redColor=RGB(255,0,0); 

static COLORREF blueColor=RGB(0,0,255); 

static COLORREF greenColor=RGB(0,255,0); 


void SetWindowHandle(HWND hwnd){ 

sHwnd=hwnd; 

} 

/* SetPixel */ 

void setPixel(int x,int y,COLORREF& color=redColor){ 

if(sHwnd==NULL){ 

    MessageBox(NULL,"sHwnd was not initialized !","Error",MB_OK|MB_ICONERROR); 

    exit(0); 

} 

HDC hdc=GetDC(sHwnd); 

SetPixel(hdc,x,y,color); 

ReleaseDC(sHwnd,hdc); 

return; 

// NEVERREACH // 

} 


void drawLineDDA(int xa, int ya, int xb, int yb){ 

    int dx = xb - xa, dy = yb - ya, steps, k; 

    float xIncrement, yIncrement, x = xa, y = ya; 

    if(abs(dx) > abs(dy)) steps = abs(dx); 

    else steps = abs(dy); 

    xIncrement = dx/(float) steps; 

    yIncrement = dy/(float) steps; 

    setPixel(ROUND(x), ROUND(y)); 

    for(int k = 0; k < steps; k++){ 

    x += xIncrement; 

    y += yIncrement; 

    setPixel(x, y); 

} 

} 

/* Window Procedure WndProc */ 

LRESULT CALLBACK WndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam){ 

switch(message){ 

    case WM_PAINT: 

     SetWindowHandle(hwnd); 

     drawLineDDA(10, 20, 250, 300); 

     break; 

    case WM_CLOSE: // FAIL THROUGH to call DefWindowProc 

     break; 

    case WM_DESTROY: 

     PostQuitMessage(0); 

     return 0; 

    default: 

    break; // FAIL to call DefWindowProc // 

    } 

return DefWindowProc(hwnd,message,wParam,lParam); 

} 

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int  iCmdShow){ 

static TCHAR szAppName[] = TEXT("Straight Line"); 

WNDCLASS wndclass; 

wndclass.style   = CS_HREDRAW|CS_VREDRAW ; 

wndclass.lpfnWndProc = WndProc ; 

wndclass.cbClsExtra = 0 ; 

wndclass.cbWndExtra = 0 ; 

wndclass.hInstance  = hInstance ; 

wndclass.hIcon   = LoadIcon (NULL, IDI_APPLICATION) ; 

wndclass.hCursor  = LoadCursor (NULL, IDC_ARROW) ; 

wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ; 

wndclass.lpszMenuName = NULL ; 

wndclass.lpszClassName = szAppName ; 

// Register the window // 

if(!RegisterClass(&wndclass)){ 

    MessageBox(NULL,"Registering the class failled","Error",MB_OK|MB_ICONERROR); 

    exit(0); 

} 

// CreateWindow // 

HWND hwnd=CreateWindow(szAppName,"DDA - Programming Techniques", 

      WS_OVERLAPPEDWINDOW, 

      CW_USEDEFAULT, 

      CW_USEDEFAULT, 

      CW_USEDEFAULT, 

      CW_USEDEFAULT, 

      NULL, 

      NULL, 

      hInstance, 

      NULL); 

if(!hwnd){ 

    MessageBox(NULL,"Window Creation Failed!","Error",MB_OK); 

    exit(0); 

    } 

    // ShowWindow and UpdateWindow // 

    ShowWindow(hwnd,iCmdShow); 

UpdateWindow(hwnd); 

// Message Loop // 

MSG msg; 

while(GetMessage(&msg,NULL,0,0)){ 

    TranslateMessage(&msg); 

    DispatchMessage(&msg); 

} 

    /* return no error to the operating system */ 

    return 0; 

} 

In questo programma ho usato la linea DDA disegno algoritmo. Le attività di disegno dei pixel sono eseguite da setPixel (ROUND (x), ROUND (y)). Si tratta di programmazione finestre che si può imparare i dettagli here

1

windows.h fornisce una funzione di SetPixel() per stampare un pixel in posizione specificata di una finestra. La forma generale della funzione è

SetPixel(HDC hdc, int x, int y, COLORREF& color); 

dove, x e y sono le coordinate del pixel da visualizzare e il colore è il colore del pixel.

Importante: per stampare il pixel nella vostra macchina con blocchi di codice :: IDE, aggiungere una libreria di collegamento libgdi32.a (di solito è all'interno MinGW\lib) in ambiente linker.

0

Per utilizzare in CodeBlocks ho trovato questo (si deve aggiungere un'opzione di linker -lgdi32): // blocchi di codice: Progetto Build Options impostazioni del linker Othoer opzioni del linker: aggiungere -lgdi32

ho dimenticato: Hai per inserire ciò prima di includere windows.h: #define _WIN32_WINNT 0x0500

L'intero codice coseno di nuovo. Pronto per la compilazione

//Code Blocks: Project Build Options Linker settings Othoer linker options: add -lgdi32 
#define _WIN32_WINNT 0x0500 
#include "windows.h" 
#include <iostream> 
#include <cmath> 
using namespace std; 
#define PI 3.14 
int main(){ 
    HWND myconsole = GetConsoleWindow(); 
    HDC mydc = GetDC(myconsole); 
    int pixel =0; 
    COLORREF COLOR= RGB(255,255,255); 

    //Draw pixels 
    for(double i = 0; i < PI * 4; i += 0.05) 
    { 
     SetPixel(mydc,pixel,(int)(50+25*cos(i)),COLOR); 
     pixel+=1; 
    } 

    ReleaseDC(myconsole, mydc); 
    cin.ignore(); 
    return 0; 
} 
Problemi correlati