libreria graphics.h en visual c++ 6.0

david1981 · #1 (**permalink**) 18/10/2006, 10:48

Hola me gustaria saber como y donde la encuentro la libreria graphics.h para Visual C++ 6.0.
Y una vez instalada como la podria linkar al Visual.
Muchas gracias.

Developer9 · #2 (**permalink**) 18/10/2006, 10:51

¿Aquella librería acaso no es exclusividad de BorlandC?

david1981 · #3 (**permalink**) 18/10/2006, 11:30

pues entonces cual es la libreria de graficos para c++.

Eternal Idol · #4 (**permalink**) 18/10/2006, 11:37

Ninguna ...

Instru · #5 (**permalink**) 18/10/2006, 14:23

Jajajaja, asi es, no existe libreria estandar para visual C++ y mucho menos para C/C++.

Saludos

Developer9 · #6 (**permalink**) 18/10/2006, 14:47

Hay que programar en BorlandC

Eternal Idol · #7 (**permalink**) 18/10/2006, 14:59

Cita:

Iniciado por Developer9

Hay que programar en BorlandC

Por supuesto ... nada mejor que una reliquia obsoleta, no standard que genera codigo para el ultimo S.O. de Microsoft ...

david1981 · #8 (**permalink**) 18/10/2006, 15:47

pero si instalo opengl, si que podria dibujar... un circulo, pero no se como empezar.
A ver si alguién me podria guiar.

Instru · #9 (**permalink**) 18/10/2006, 19:33

Jajajaja, vale, para circulos y comienzos faciles usa una libreria sencilla.

Intenta usar allegro o SDL, te haran la vida muy facil aparte de que despues los puedes usar como el sustituto del obsoleto glut para OpenGL.

saludos

Nivel7 · #10 (**permalink**) 18/10/2006, 19:36

la libreria openGL, se incluye en el compilador de Visual C++, tan solo tienes que
incluir los respectivos encabezados y linkar con sus librerias.

pero openGL, es recomendable para programacion 3D y seria muy complicada para un programador novato.

mira el Visual C++, incluye una libreria grafica propia que es la MFC, yo nunca la he usado pero segun te facilita mas que usando directamente la API de Windows.

si aun insistes en usar openGL, la puedes usar con glaux, que tambien la incluye en VC++, aunque actualmente se usa mas GLUT, sin embargo son un tanto similares.

este es un ejemplo muy clasico para la iniciacion en openGL.
se usa la WinAPI.

Código:

/**************************
 * Includes
 *
 **************************/

#include <windows.h>
#include <gl/gl.h>


/**************************
 * Function Declarations
 *
 **************************/

LRESULT CALLBACK WndProc (HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam);
void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC);
void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC);


/**************************
 * WinMain
 *
 **************************/

int WINAPI WinMain (HINSTANCE hInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpCmdLine,
                    int iCmdShow)
{
    WNDCLASS wc;
    HWND hWnd;
    HDC hDC;
    HGLRC hRC;        
    MSG msg;
    BOOL bQuit = FALSE;
    float theta = 0.0f;

    /* register window class */
    wc.style = CS_OWNDC;
    wc.lpfnWndProc = WndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor (NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = "GLSample";
    RegisterClass (&wc);

    /* create main window */
    hWnd = CreateWindow (
      "GLSample", "OpenGL Sample", 
      WS_CAPTION | WS_POPUPWINDOW | WS_VISIBLE,
      0, 0, 256, 256,
      NULL, NULL, hInstance, NULL);

    /* enable OpenGL for the window */
    EnableOpenGL (hWnd, &hDC, &hRC);

    /* program main loop */
    while (!bQuit)
    {
        /* check for messages */
        if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
        {
            /* handle or dispatch messages */
            if (msg.message == WM_QUIT)
            {
                bQuit = TRUE;
            }
            else
            {
                TranslateMessage (&msg);
                DispatchMessage (&msg);
            }
        }
        else
        {
            /* OpenGL animation code goes here */

            glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
            glClear (GL_COLOR_BUFFER_BIT);

            glPushMatrix ();
            glRotatef (theta, 0.0f, 0.0f, 1.0f);
            glBegin (GL_TRIANGLES);
            glColor3f (1.0f, 0.0f, 0.0f);   glVertex2f (0.0f, 1.0f);
            glColor3f (0.0f, 1.0f, 0.0f);   glVertex2f (0.87f, -0.5f);
            glColor3f (0.0f, 0.0f, 1.0f);   glVertex2f (-0.87f, -0.5f);
            glEnd ();
            glPopMatrix ();

            SwapBuffers (hDC);

            theta += 1.0f;
            Sleep (1);
        }
    }

    /* shutdown OpenGL */
    DisableOpenGL (hWnd, hDC, hRC);

    /* destroy the window explicitly */
    DestroyWindow (hWnd);

    return msg.wParam;
}


/********************
 * Window Procedure
 *
 ********************/

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

    switch (message)
    {
    case WM_CREATE:
        return 0;
    case WM_CLOSE:
        PostQuitMessage (0);
        return 0;

    case WM_DESTROY:
        return 0;

    case WM_KEYDOWN:
        switch (wParam)
        {
        case VK_ESCAPE:
            PostQuitMessage(0);
            return 0;
        }
        return 0;

    default:
        return DefWindowProc (hWnd, message, wParam, lParam);
    }
}


/*******************
 * Enable OpenGL
 *
 *******************/

void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC)
{
    PIXELFORMATDESCRIPTOR pfd;
    int iFormat;

    /* get the device context (DC) */
    *hDC = GetDC (hWnd);

    /* set the pixel format for the DC */
    ZeroMemory (&pfd, sizeof (pfd));
    pfd.nSize = sizeof (pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW | 
      PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;
    iFormat = ChoosePixelFormat (*hDC, &pfd);
    SetPixelFormat (*hDC, iFormat, &pfd);

    /* create and enable the render context (RC) */
    *hRC = wglCreateContext( *hDC );
    wglMakeCurrent( *hDC, *hRC );

}


/******************
 * Disable OpenGL
 *
 ******************/

void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC)
{
    wglMakeCurrent (NULL, NULL);
    wglDeleteContext (hRC);
    ReleaseDC (hWnd, hDC);
}

este otro es el mismo ejemplo de openGL pero ahora se usa SDL.

Código:

#include <SDL/SDL.h>
#include <gl/gl.h>

/*
 PLEASE NOTE: the program will require SDL.dll which is located in
              dev-c++'s dll directory. You have to copy it to you
			  program's home directory or the path.
 */

int main(int argc, char *argv[]){
  SDL_Event event;
  float theta = 0.0f;

  SDL_Init(SDL_INIT_VIDEO);
  SDL_SetVideoMode(300, 300, 0, SDL_OPENGL | SDL_HWSURFACE);

  glViewport(0, 0, 300, 300);
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  glClearDepth(1.0);
  glDepthFunc(GL_LESS);
  glEnable(GL_DEPTH_TEST);
  glShadeModel(GL_SMOOTH);
  glMatrixMode(GL_PROJECTION);
  glMatrixMode(GL_MODELVIEW);

  int done;
  for(done = 0; !done;){
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();
    glTranslatef(0.0f,0.0f,0.0f);
    glRotatef(theta, 0.0f, 0.0f, 1.0f);

    glBegin(GL_TRIANGLES);
    glColor3f(1.0f, 0.0f, 0.0f);
    glVertex2f(0.0f, 1.0f);
    glColor3f(0.0f, 1.0f, 0.0f);
    glVertex2f(0.87f, -0.5f);
    glColor3f(0.0f, 0.0f, 1.0f);
    glVertex2f(-0.87f, -0.5f);
    glEnd();

    theta += .5f;
    SDL_GL_SwapBuffers();
    SDL_PollEvent(&event);
    if(event.key.keysym.sym == SDLK_ESCAPE)
      done = 1;
  }
  SDL_Quit();
  return(0);
}

Saludos.

FlyFox · #11 (**permalink**) 19/10/2006, 07:18

usa glut, es facil de usar, aunque digan que esta obsoleto y hueas, es facil. Un buen tutorial esta en lighthouse 3d(busca en google, no me deja postiar links)

Instru · #12 (**permalink**) 19/10/2006, 12:25

Cita:

usa glut, es facil de usar, aunque digan que esta obsoleto y hueas, es facil. Un buen tutorial esta en lighthouse 3d(busca en google, no me deja postiar links)

Se nota que no sabes que es SDL ni allegro, verdad?

Saludos

david1981 · #13 (**permalink**) 19/10/2006, 14:44

yo puse lo de opengl, pq ya me lo habia instalado... o sea q tirare por el opengl a ver q tal.... merci a todos

Instru · #14 (**permalink**) 19/10/2006, 21:41

Pues a darle. ahi nos avisas que tal te va.

Saludos

MaxExtreme · #15 (**permalink**) 20/10/2006, 06:01

Cita:

Iniciado por Nivel7

mira el Visual C++, incluye una libreria grafica propia que es la MFC, yo nunca la he usado pero segun te facilita mas que usando directamente la API de Windows.

La MFC es una abstracción POO (basada en C++) de la API de Windows. No es ni más fácil ni más difícil.

Y no, no es una librería gráfica. La librería gráfica de Windows es GDI.

Nivel7 · #16 (**permalink**) 21/10/2006, 01:52

ya vaz, claro que lo sé, pero la MFC, tiene un conjunto de clases, que encapsulan las funciones del GDI, a esto me refería.
y al hecho de tener que usar una ventana para poder dibujar en Windows.
MFC tiene para eso.

dejemos esto asi, al fin ya se decidio, por OpenGL.