Red de conocimiento informático - Material del sitio web - ¿Cómo dibujar una escena 3D basada en VC++?

¿Cómo dibujar una escena 3D basada en VC++?

/*

* Ejemplo de programa OpenGL del sistema X Window.

* El código OpenGL se toma de auxdemo.c en Platform SDK

*/

#include &. >

#include

#include

#include

#include <.X11/Xlib.h>

#include

#include

/ * Ninguno};

#define SWAPBUFFERS glXSwapBuffers(dpy, glwin)

#define BLACK_INDEX 0

#define RED_INDEX 1

# define GREEN_INDEX 2

#define BLUE_INDEX 4

#define WIDTH 300

#define HEIGHT 200

/* Globales OpenGL, definiciones y prototipos */

GLfloat latitud, longitud, latinc.longinc

GLdoble radio

#define GLOBE 1

#define CILINDRO; 2

#define CONO 3

GLvoid resize(GLsizei, GLsizei);

GLvoid inicializaGL(GLsizei, GLsizei

);

GLvoid drawScene(GLvoid);

void polarView(GLdouble, GLdouble, GLdouble, GLdouble

static Bool WaitForMapNotify(Display *d, XEvent *e, char *arg); )

{

if ((e->type == MapNotify) && (e->xmap.window == (Window)arg)) {

Devuelve GL_TRUE

}

Devuelve GL_TRUE.

Devuelve GL_FALSE

}

void

main(int argc, char **argv)

{

XVisualInfo *vi;

Mapa de colores cmap;

XSetWindowAttributes swa; evento

GLboolean needRedraw = GL_FALSE, recalcModelView = GL_TRUE;

int dummy

dpy = XOpenDisplay(NULL); ( dpy == NULL){

fprintf( stderr, "no se pudo abrir la pantalla\n");

exit(1); p>

if (!glXQueryExtension(dpy, &dummy, &dummy)){

fprintf( stderr, "no se pudo abrir la pantalla");

exit(1); /p>

}

/* Encuentre una visualización indexada por colores con búfer de profundidad y soporte OpenGL*/

vi = glXChooseVisual(dpy, DefaultScreen(dpy), atributos)

if (vi == NULL) {

fprintf(stderr, "no se pudo obtener visual\n");

exit(1) <; /p>

}

/* Crear contexto de representación OpenGL*/

cx = glXCreateContext(dpy, vi, None, GL_TRUE

if); (cx == NULL) {

fprintf(stderr, "no se pudo crear el contexto de representación\n");

exit(1); /p>

/* Crea un mapa de color X, porque no se puede utilizar el efecto visual predeterminado*/

cmap = >

vi->visual, AllocNone

);

swa.colormap = cmap;

swa.border_pixel = 0;

swa.border_pixel = 0

swa.colormap = cmap; p>

swa.border_pixel = 0event_mask = ExposureMask | KeyPressMask | StructureNotifyMask

glwin = XCreateWindow(dpy, RootWindow(dpy, vi->pantalla), 0, 0, WIDTH,

ALTURA, 0, vi-> profundidad, EntradaSalida, vi->visual,

CWBor

derPixel | CWColormap | CWEventMask, &swa);

XSetStandardProperties (dpy, glwin, "xogl", "xogl", Ninguno,

argc,

);

glXMakeCurrent(dpy, glwin, cx);

XMapWindow(dpy, glwin);

XIfEvent(dpy, &event, WaitForMapNotify, (char *)glwin p>

inicializarGL(ANCHO, ALTO);

resize(ANCHO, ALTO);

/* bucle de animación*/

while ( 1) {

tecla KeySym

while (XPending(dpy)) {

XNextEvent(dpy, &event> interruptor); (evento .tipo) {

case KeyPress:

XLookupString((XKeyEvent *)&event, NULL, 0, &. key,

switch); (clave) {

case XK_Left:

longinc += 0.5

break

case XK_Right:

longinc -= 0,5;

descanso;

caso XK_Up:

latinc += 0,5; >

caso XK_Down:

latinc -= 0.5

descanso

}

descanso

Configurar caso.

caso ConfigureNotify:

resize(event.xconfigure.width, event.xconfigure.height);

break;

}

}

dibujarEscena();

}

}

}

/* Código OpenGL*/

GLvoid resize( GLsizei ancho, GLsizei alto )

{

Aspecto GLfloat

p>

p>

Aspecto GLfloat;

glViewport( 0, 0, ancho, alto

aspecto = (GLfloat) ancho/alto; >

glMatrixMode (GL_PROJECTION);

glLoadIdentity();

gluPerspective( 45.0, aspecto, 3.0, 7.0 );

}

GLvoid createObjects()

{

GLUquadricObj *quadObj

glNewList(GLOBE, GL_COMPILE;

quadObj = gluNewQuadric ();

gluQuadricDrawStyle (quadObj, GLU_ LINE

gluSphere (quadObj, 1.5, 16, 16); p>

glEndList();

glNewList(CONE, GL_COMPILE);

quadObj = gluNewQuadric ();

gluQuadricDrawStyle (quadObj, GLU_FILL);

gluQuadricNormals (quadObj, GLU_SMOOTH);

gluCylinder(quadObj, 0.3, 0.0, 0.6, 15, 10 );

glEndList(); >

glNewList (CYLINDER, GL_COMPILE);

glPushMatrix ();

glRotatef ((GLfloat)90.0, (GLfloat)1.0, (GLfloat)0.0, (GLfloat)0.0

glTranslatef ((GLfloat)0.0, (GLfloat)0.0, (GLfloat)-1.0);

quadObj = gluNewQuadric();

gluQuadricDrawStyle( quadObj, GLU_FILL);

gluQuadricNormals(quadObj, GLU_SMOOTH);

gluCylinder(quadObj, 0.3, 0.3, 0.6, 12, 2);

glPopMatrix (

glEndList());

}

GLvoid inicializarGL(GLsizei ancho, GLsizei alto)

{

GLfloat maxObjectSize, aspecto; p> GLdouble plano_cercano, plano_lejano;

glClearIndex( (GLfloat)BLACK_INDEX);

glClearDepth( 1.0 );

glEnable(GL_DEPTH_TEST);

glMatrixMode( GL_PROJECTION );

aspecto = (GLfloat) ancho / alto

gluPerspective( 45.3.0, 7.0

glMatrixMode( GL_MODELVIEW );

near_plane = 3.0;

far_plane = 7.0;

maxObjectSize = 3.0F

radio = cerca de _plane + maxObjectSize/ 2,0;

latitud = 0,0F;

longitud = 0,0F;

latín = 6,0F

longitud = 2,5F;

createObjects().

}

void polarView(GLdoble radio, GLdoble giro, GLdoble latitud,

GLdoble longitud)

p>

{

glTranslated( 0.0, 0.0, -radius);

glRotated(-twist, 0.0, 0.0, 1.0); >

glRotated (-latitud, 1,0, 0,0, 0,0

glRotated(longitud, 0,0, 0,0, 1,0);

}

GLvoid); drawScene(GLvoid)

{

glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT

glPushMatrix()

latitud + = latinc;

p>

longitud += longinc;

polarView( radio, 0, latitud, longitud

glIndexi(RED_INDEX);

glCallList(CONO );

glIndexi(BLUE_INDEX);

glCallList(GLOBE);

glIndexi(GREEN_INDEX); p>

glPushMatrix();

glTranslatef(0.8F, -0.65F, 0.0F);

glRotatef(30.0F, 1.0F, 0.5F, 1.0F) ;

glCallList( CILINDRO);

glPopMatrix();

glPopMatrix();

INTERCAMBIADORES

}