Teclado

[Mana]

He hecho un programita que reproduce 6 letras tal y como las he escrito antes en un papel mediante curvas de bezier, pero tengo un problema. Estas letras deberían aparecer en pantalla confome yo vaya pulsando esas letras en el teclado, pero no se como hacerlo... ¿alguien me podría ayudar?

Aki os dejo el codigo para las letras G y E...



void Dibuja_Puntos (wcPt3D bezCurvePt)
{
glColor3f (1.0, 0.0, 0.0); // Establece el color de los puntos en rojo.
glPointSize (3); // Establece el tamaño de los puntos
glBegin (GL_POINTS); // Comienza a dibujar puntos
glVertex2f (bezCurvePt.x, bezCurvePt.y); // Dibuja el punto en la coordenada establecida
glEnd ( );
}


void Dibuja_Puntos_Control(wcPt3D ctrlPts [3])
{
glColor3f (0.0, 0.0, 1.0); // Establece el color de los puntos en azul
glPointSize (5); // Establece el tamaño de los puntos de control
glBegin (GL_POINTS); // Comienza a dibujar puntos
for(int i=0; i<3;i++)
glVertex2f (ctrlPts .x, ctrlPts .y); // Dibuja el punto en la coordenada establecida
glEnd ( );

glBegin (GL_LINE_STRIP); // Comienza a dibujar una polilinea
for( i=0; i<3;i++)
glVertex2f (ctrlPts .x, ctrlPts .y); // Dibuja el punto en la coordenada establecida de la polilinea
glEnd ( );
glFlush();
}

// Calcula los coeficientes binomiales C para un valor dado de n.

void binomialCoeffs (GLint n, GLint * C)
{
GLint k, j;

// Compute n!/(k!(n k)!)
for (k = 0; k <= n; k++)
{
C [k] = 1;
for (j = n; j >= k + 1; j--)
C [k] *= j ;
for (j = n - k; j >= 2; j--)
C [k] /= j ;
}
}

void computeBezPt (GLfloat u, wcPt3D * bezPt, GLint nCtrlPts, wcPt3D *
ctrlPts, GLint * C)

{
GLint k, n = nCtrlPts - 1;
GLfloat bezBlendFcn;

bezPt->x = bezPt->y = 0.0;

// Calcula las funciones de combinación y los puntos de control de combinación.
for (k = 0; k < nCtrlPts; k++)
{
bezBlendFcn = C [k] * pow (u, k) * pow (1- u, n - k) ;
bezPt->x += ctrlPts [k].x * bezBlendFcn;
bezPt->y += ctrlPts [k].y * bezBlendFcn;
}
}

void bezier (wcPt3D * ctrlPts, GLint nCtrlPts, GLint nBezCurvePts)
{
wcPt3D bezCurvePt;
GLfloat u;
GLint *C, k;


// Reserva espacio para los coeficientes binomiales
C = new GLint [nCtrlPts];
binomialCoeffs (nCtrlPts - 1, C);

for (k = 0; k<= nBezCurvePts; k++)
{
u = GLfloat (k) / GLfloat (nBezCurvePts);
computeBezPt (u, &bezCurvePt, nCtrlPts, ctrlPts, C);
Dibuja_Puntos (bezCurvePt); //Dibuja Puntos
}
delete [ ] C;
}

void dibujo (void)
{

glClear (GL_COLOR_BUFFER_BIT); // Borra la ventana de visualización.
// Establece un número de puntos de cor,troi de ejemplo y un número de
// puntos de curva que se deben dibujar a lo largo de la curva de Bezier.
GLint numero_Pts_Control = 3, numero_Pts_Curva = 1000;

// COMIENZA G EN TRAZOS

wcPt3D ctrlPts [3] = { {10.0, 10.0},
{0.0, 10.0},
{0.0, 5.0}
};

Dibuja_Puntos_Control (ctrlPts); //Dibuja Puntos de control

bezier (ctrlPts, numero_Pts_Control, numero_Pts_Curva);

wcPt3D ctrlPts2 [3] = { { 0.0, 5.0},
{ 0.0, 0.0},
{ 5.0, 0.0}
};

Dibuja_Puntos_Control (ctrlPts2); //Dibuja Puntos de control

bezier (ctrlPts2, numero_Pts_Control, numero_Pts_Curva);


wcPt3D ctrlPts3 [3] = { { 5.0, 0.0},
{ 10.0, 0.0},
{ 10.0, 7.0}
};

Dibuja_Puntos_Control (ctrlPts3); //Dibuja Puntos de control

bezier (ctrlPts3, numero_Pts_Control, numero_Pts_Curva);

wcPt3D ctrlPts4 [3] = { {10.0, 7.0},
{10.0, 5.0},
{5.0, 5.0}
};

Dibuja_Puntos_Control (ctrlPts4); //Dibuja Puntos de control

bezier (ctrlPts4, numero_Pts_Control, numero_Pts_Curva);
//FIN DE G

//PRINCIPIO E EN 6 TRAMOS

wcPt3D ctrlPts5 [3] = { { 30.0, 8.0},
{ 30.0, 10.0},
{ 25.0, 10.0}
};

Dibuja_Puntos_Control (ctrlPts5); //Dibuja Puntos de control

bezier (ctrlPts5, numero_Pts_Control, numero_Pts_Curva);

wcPt3D ctrlPts6 [3] = { { 25.0, 10.0},
{20.0, 10.0},
{20.0, 5.0}
};

Dibuja_Puntos_Control (ctrlPts6); //Dibuja Puntos de control

bezier (ctrlPts6, numero_Pts_Control, numero_Pts_Curva);


wcPt3D ctrlPts7 [3] = { {20.0, 5.0},
{20.0, 0.0},
{25.0, 0.0}
};

Dibuja_Puntos_Control (ctrlPts7); //Dibuja Puntos de control

bezier (ctrlPts7, numero_Pts_Control, numero_Pts_Curva);

wcPt3D ctrlPts8 [3] = { {25.0, 0.0},
{30.0, 0.0},
{30.0, 1.5}
};

Dibuja_Puntos_Control (ctrlPts8); //Dibuja Puntos de control

bezier (ctrlPts8, numero_Pts_Control, numero_Pts_Curva);


wcPt3D ctrlPts9 [3] = { { 30.0, 8.0},
{ 30.0, 5.0},
{ 25.0, 5.0}
};

Dibuja_Puntos_Control (ctrlPts9); //Dibuja Puntos de control

bezier (ctrlPts9, numero_Pts_Control, numero_Pts_Curva);



wcPt3D ctrlPts10 [3] = { { 25.0, 5.0},
{ 20.0, 3.0},
{ 20.0, 5.0}
};

Dibuja_Puntos_Control (ctrlPts10); //Dibuja Puntos de control

bezier (ctrlPts10, numero_Pts_Control, numero_Pts_Curva);

// FIN DE E
glFlush ( );
}

void winReshapeFcn (GLint nuevo_An, GLint nuevo_Al)
{
// Mantiene una relación de aspeto de valor 1.0.
glViewport (0, 0, nuevo_An, nuevo_Al);

glMatrixMode (GL_PROJECTION); glLoadIdentity ( );

gluOrtho2D (xuMin, xuMax, yuMin, yuMax);
glClear (GL_COLOR_BUFFER_BIT);
}

int main (int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition (150,150);
glutInitWindowSize (An, Al);
glutCreateWindow ("Curva de Bezier codigo según Hearn & Baker");

inicio();
glutDisplayFunc (dibujo);
glutReshapeFunc (winReshapeFcn);

glutMainLoop();
return 0;
}




Gracias. Ups... Trabajo con Visual C++  :P

[Pogacha]

Que tal,

1 - Hacer que dibujar cada letra sea una función o una lista de oGl.
2 - Hacer un vector para que guarde las teclas que se van pulsando.
3 - Hacer un loop del estilo:

Código [Seleccionar] Expand

int n=0;
char vector[256];
do {
 char c = getkey();
 vector[n++]=c;
 for(int i=0; i<n; i++)  Dibujar_Letra(vector[i]);
} while(c!='q');

Tendras que tener en cuenta el desplazamiento de los caracteres a medida que se dibujan. Aparte el main loop lo controla glut así que tendras que adaptar este codigo.
Saludos y suerte