L'exécutable

• x, X, y, Y, z et Z pour tourner la scène
• Enter pour switcher entre 2, 3, 4, 5 et 6 points

En bleu la courbe générée automatiquement par OpenGL, en magenta la courbe obtenue par la formule

Le source : BezierFormule.cpp

Le source : ModuleFont.cpp

Le source : ModuleFont.h

#include <windows.h>

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glaux.h>

#include <math.h>
#include <stdio.h>

#include "modulefont.h"

static GLfloat pts[6][3] = { 
  {-3.0,-3.0,-3.0},{-2.0,3.0,1.0}, 
  { 2.0,-3.0,-2.0},{ 3.0,3.0,-3.0}, 
  { -2.0,-1.0,2.0},{ 3.0,-3.0,-1.0}}; 
static GLfloat view_rotx=0.0F ;
static GLfloat view_roty=0.0F ;
static GLfloat view_rotz=0.0F ;
static int aff = 2 ;
  
struct coord_3D {
  GLfloat x,y,z ; } ;
struct polygone {
  int n ;
  coord_3D *p ; } ;

void pixel(float x,float y,float z) {
    glVertex3f(x,y,z); 
  }

double power(double v,int p) {
  return(( !v && !p ) ?
    1.:
    pow(v,(double) p)) ;
}

void bezier(polygone *p,
            int n) {
  int i,j ;
  float t,mt ;
  float *cn,x,y,z,fac ;
  cn =(float *) calloc(p->n,sizeof(float)) ;
  cn[0] = 1 ;
  cn[1] =(float) (p->n-1) ;
  for ( i = 2 ; i < p->n ; i++ )
    cn[i] = cn[i-1] * (p->n - i) / i ;
  for ( i = 0 ; i < n ; i++ ) {
    t =(float) i/(n-1) ;
    mt = 1-t ;
    x = y = z = 0.0F ;
    for ( j = 0 ; j < p->n ; j++ ) {
      fac = cn[j]*(float) power(t,j)*
                  (float) power(mt,p->n-1-j) ;
      x += fac * p->p[j].x ;
      y += fac * p->p[j].y ;
      z += fac * p->p[j].z ; }
    pixel(x,y,z) ; }
  free(cn) ;
}

polygone pl = { aff,(coord_3D *) &pts[0][0] } ;

void CALLBACK display(void) { 
  int i; 
  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); 
  glPushMatrix();
  glEnable(GL_DEPTH_TEST);
  glRotatef(view_rotx,1.0,0.0,0.0);
  glRotatef(view_roty,0.0,1.0,0.0);
  glRotatef(view_rotz,0.0,0.0,1.0);
  glColor3f(0.0,1.0,1.0); 
  glBegin(GL_LINE_STRIP); 
  for( i = 0 ; i <= 30 ; i++ ) 
    glEvalCoord1f((GLfloat) i/30.0F); 
  glEnd(); 
  glPointSize(5.0); 
  glColor3f(1.0,1.0,0.0); 
  glBegin(GL_POINTS); 
  for( i = 0 ; i < aff ; i++ ) 
    glVertex3fv(&pts[i][0]); 
  glEnd(); 
  glColor3f(1.0,0.0,1.0); 
  glPointSize(3.0); 
  glBegin(GL_POINTS); 
  bezier(&pl,40);
  glEnd(); 
  glDisable(GL_DEPTH_TEST);
  glColor3f(1.0,1.0,0.0); 
  for( i = 0 ; i < aff ; i++ )  {
    glRasterPos3f(pts[i][0]+0.3F,pts[i][1]+0.3F,pts[i][2]+0.3F);
    char st[50] ;
    sprintf(st,"%d",i);
    printString(st); }
  glPopMatrix();
  glFlush();
  auxSwapBuffers();
} 

void CALLBACK myReshape(int w,int h) { 
  glViewport(0,0,w,h); 
  glMatrixMode(GL_PROJECTION); 
  glLoadIdentity(); 
  if( w <= h ) 
    glOrtho(-5.,5.,-5.*(float)h/(float)w,5.*(float)h/(float)w,-7.,7.); 
    else 
    glOrtho(-5.*(float)w/(float)h,5.*(float)w/(float)h,-5.,5.,-7.,7.); 
  glMatrixMode(GL_MODELVIEW); 
  glLoadIdentity(); 
} 
  
void myinit(void) { 
  makeRasterFont();
  glClearColor(0.0,0.0,0.0,1.0); 
  glMap1f(GL_MAP1_VERTEX_3,0.0,1.0,3,aff,&pts[0][0]); 
  glEnable(GL_MAP1_VERTEX_3); 
  glShadeModel(GL_FLAT); 
  glDepthFunc(GL_LESS);
} 
  
void CALLBACK keyx(void) {
  view_rotx += 2 ;
}

void CALLBACK keyX(void) {
  view_rotx -= 2 ;
}

void CALLBACK keyy(void) {
  view_roty += 2 ;
}

void CALLBACK keyY(void) {
  view_roty -= 2 ;
}

void CALLBACK keyz(void) {
  view_rotz += 2 ;
}

void CALLBACK keyZ(void) {
  view_rotz -= 2 ;
}

void CALLBACK keyReturn(void) {
  aff++ ;
  if ( aff == 7 )
    aff = 2 ;
  pl.n = aff ;
  glMap1f(GL_MAP1_VERTEX_3,0.0,1.0,3,aff,&pts[0][0]); 
}

void main(void) { 
  auxInitDisplayMode(AUX_DOUBLE|AUX_RGBA|AUX_DEPTH); 
  auxInitPosition(0,0,300,300); 
  auxInitWindow("Courbe de Bezier"); 
  myinit(); 
  auxKeyFunc(AUX_x,keyx) ;
  auxKeyFunc(AUX_X,keyX) ;
  auxKeyFunc(AUX_y,keyy) ;
  auxKeyFunc(AUX_Y,keyY) ;
  auxKeyFunc(AUX_z,keyz) ;
  auxKeyFunc(AUX_Z,keyZ) ;
  auxKeyFunc(AUX_RETURN,keyReturn) ;
  auxReshapeFunc(myReshape); 
  auxMainLoop(display); 
} 

 RETOUR