SoloCodigo

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.

Pero... como tendría k hacerlo??  Tendría que dividir en dos funciones, una para la letra G y otra para la E?? Como lo haria??

Gracias

.... Sorry!!... soy duro de mollera... pero no lo acabo de entender...

void MyFuncion(char key, int x, int y)
{
switch(key)
case A: do something; break;
case B: do another something; break;
}
}


A ver... el ejemplo lo entiendo y ya lo he usado para otro programa, pero no se como ponerlo para ese caso en particular, ya que en el ejemplo que he puesto arriba está todo dentro de la función void dibujo( )... En el case A, ¿cómo lo pudo poner para que solamente me haga la letra G?? Es que por más vueltas que le doy y por mas pruebas que hago no me sale...  


Gracias