void drawCurves(GLenum mode) {
/* Draw the curves */
glColor3f(0,0,0);
for(int i=0; i<OUTER_CPTS-3; i +=3) {
if (mode == GL_SELECT) {
glLoadName(i);
}
/* Draw the outer curve using OpenGL evaluators */
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, cpts[i]);
glMapGrid1f(30, 0.0, 1.0);
glEvalMesh1(GL_LINE, 0, 30);
}
for(int i=0; i<INNER_CPTS-3; i +=3) {
if (mode == GL_SELECT) {
glLoadName(i+OUTER_CPTS);
}
/* Draw the inner curve using OpenGL evaluators */
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, cpts[OUTER_CPTS+i]);
glMapGrid1f(30, 0.0, 1.0);
glEvalMesh1(GL_LINE, 0, 30);
}
glFlush();
}
void drawCurves() {
int i;
GLfloat gain;
/* Draw the curves */
glColor3f(0,0,0);
for(i=0; i<OUTER_CPTS-3; i +=3) {
/* Draw the outer curve using OpenGL evaluators */
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, cpts[i]);
glMapGrid1f(30, 0.0, 1.0);
glEvalMesh1(GL_LINE, 0, 30);
}
for(i=0; i<INNER_CPTS-3; i +=3) {
/* Draw the inner curve using OpenGL evaluators */
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, cpts[OUTER_CPTS+i]);
glMapGrid1f(30, 0.0, 1.0);
glEvalMesh1(GL_LINE, 0, 30);
}
glFlush();
// determin gain
for(i=0;i<ncpts;i++){
cpts[i][0]=(-16.0+cpts[i][0])/20.0;
cpts[i][1]=(-16.0+cpts[i][1])/20.0;
cpts[i][2]=cpts[i][2];
//printf("\n %d %f %f",i,cpts[i][0],cpts[i][1]);
}
}
void RenderScene()
{
glClear(GL_COLOR_BUFFER_BIT);
//设置贝塞尔曲线，这个函数其实只需要调用一次，可以放在SetupRC中设置
glMap1f(GL_MAP1_VERTEX_3, //生成的数据类型
0.0f, //u值的下界
100.0f, //u值的上界
3, //顶点在数据中的间隔，x,y,z所以间隔是3
numOfPoints, //u方向上的阶，即控制点的个数
&controlPoints[0][0] //指向控制点数据的指针
);
//必须在绘制顶点之前开启
glEnable(GL_MAP1_VERTEX_3);
//使用画线的方式来连接点
/*glBegin(GL_LINE_STRIP);
for (int i = 0; i <= 100; i++)
{
glEvalCoord1f((GLfloat)i);
}
glEnd();*/
glMapGrid1f(100, 0.0f, 100.0f);
glEvalMesh1(GL_LINE, 0, 100);
DrawPoints();
glutSwapBuffers();
}
void tglDraw(const TCubic &cubic, int precision, GLenum pointOrLine)
{
CHECK_ERRORS_BY_GL;
assert(pointOrLine == GL_POINT || pointOrLine == GL_LINE);
float(*ctrlPts)[3];
ctrlPts = new float[4][3];
ctrlPts[0][0] = cubic.getP0().x;
ctrlPts[0][1] = cubic.getP0().y;
ctrlPts[0][2] = 0.0;
ctrlPts[1][0] = cubic.getP1().x;
ctrlPts[1][1] = cubic.getP1().y;
ctrlPts[1][2] = 0.0;
ctrlPts[2][0] = cubic.getP2().x;
ctrlPts[2][1] = cubic.getP2().y;
ctrlPts[2][2] = 0.0;
ctrlPts[3][0] = cubic.getP3().x;
ctrlPts[3][1] = cubic.getP3().y;
ctrlPts[3][2] = 0.0;
CHECK_ERRORS_BY_GL;
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, &ctrlPts[0][0]);
CHECK_ERRORS_BY_GL;
glEnable(GL_MAP1_VERTEX_3);
CHECK_ERRORS_BY_GL;
glMapGrid1f(precision, 0.0, 1.0);
CHECK_ERRORS_BY_GL;
glEvalMesh1(pointOrLine, 0, precision);
CHECK_ERRORS_BY_GL;
delete[] ctrlPts;
}
void __glXDisp_MapGrid1f(GLbyte *pc)
{
glMapGrid1f(
*(GLint *)(pc + 0),
*(GLfloat *)(pc + 4),
*(GLfloat *)(pc + 8)
);
}
static void hugsprim_glMapGrid1f_15(HugsStackPtr hugs_root)
{
HsInt32 arg1;
HsFloat arg2;
HsFloat arg3;
arg1 = hugs->getInt32();
arg2 = hugs->getFloat();
arg3 = hugs->getFloat();
glMapGrid1f(arg1, arg2, arg3);
hugs->returnIO(hugs_root,0);
}
void drawCurves()
{
int i;
for(i=0; i<numberOfBezierCurve; i++)
{
/* draw the curve using OpenGL evaluators */
glColor3f(BC[i].color[0], BC[i].color[1], BC[i].color[2]);
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, BC[i].cpts[0]);
glMapGrid1f(30, 0.0, 1.0);
glEvalMesh1(GL_LINE, 0, 30);
}
glFlush();
}
void Bezier()
{
glClear(GL_COLOR_BUFFER_BIT);
glLineWidth(5);
float PuntosdeControl[7][3] = {
{411.0,posy(249.0),0.0},
{505.0,posy(274.0),0.0},
{597.0,posy(239.0),0.0},
{620.0,posy(137.0),0.0},
{518.0,posy(84.0),0.0},
{414.0,posy(150.0),0.0},
{412.0,posy(248.0),0.0}
};
glMap1f(GL_MAP1_VERTEX_3,0.0,1.0,3,7,*PuntosdeControl);
glEnable(GL_MAP1_VERTEX_3);
glMapGrid1f(100,0.0,1.0);
glColor3f(1,0,0);
glEvalMesh1(GL_LINE,0,100);
glDisable(GL_MAP1_VERTEX_3);
glFlush();
}
static void cdpoly(cdCtxCanvas *ctxcanvas, int mode, cdPoint* poly, int n)
{
int i;
if (mode == CD_CLIP)
return;
if (mode == CD_BEZIER)
{
int i, prec = 100;
float (*points)[3] = malloc(n * sizeof(*points));
for(i = 0; i < n; i++)
{
points[i][0] = (float)poly[i].x;
points[i][1] = (float)poly[i].y;
points[i][2] = 0;
}
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, n, &points[0][0]);
glEnable(GL_MAP1_VERTEX_3);
glMapGrid1f(prec, 0.0, 1.0);
glEvalMesh1(GL_LINE, 0, prec);
glDisable(GL_MAP1_VERTEX_3);
free(points);
return;
}
if (mode == CD_PATH)
{
cdSimPolyPath(ctxcanvas->canvas, poly, n);
return;
}
switch (mode)
{
case CD_CLOSED_LINES :
glBegin(GL_LINE_LOOP);
break;
case CD_OPEN_LINES :
glBegin(GL_LINE_STRIP);
break;
case CD_FILL :
if(ctxcanvas->canvas->back_opacity == CD_OPAQUE && glIsEnabled(GL_POLYGON_STIPPLE))
{
/* draw twice, one with background color only, and one with foreground color */
glDisable(GL_POLYGON_STIPPLE);
glColor4ub(cdRed(ctxcanvas->canvas->background),
cdGreen(ctxcanvas->canvas->background),
cdBlue(ctxcanvas->canvas->background),
cdAlpha(ctxcanvas->canvas->background));
glBegin(GL_POLYGON);
for(i = 0; i < n; i++)
glVertex2i(poly[i].x, poly[i].y);
glEnd();
/* restore the foreground color */
glColor4ub(cdRed(ctxcanvas->canvas->foreground),
cdGreen(ctxcanvas->canvas->foreground),
cdBlue(ctxcanvas->canvas->foreground),
cdAlpha(ctxcanvas->canvas->foreground));
glEnable(GL_POLYGON_STIPPLE);
}
glBegin(GL_POLYGON);
break;
}
for(i = 0; i < n; i++)
glVertex2i(poly[i].x, poly[i].y);
glEnd();
(void)ctxcanvas;
}
void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) {
glMapGrid1f(un, u1, u2);
}
/*
* OpenGL (GLUT) calls this routine to display the scene
*/
void display()
{
int k,i;
Point S[NMAX];
// Erase the window and the depth buffer
glClear(GL_COLOR_BUFFER_BIT);
// Enable vertex generation
glEnable(GL_MAP1_VERTEX_3);
// Draw and label points
glColor3f(1,1,1);
glPointSize(5);
glBegin(GL_POINTS);
for (k=0;k<n;k++)
glVertex2f(P[k].x,P[k].y);
glEnd();
for (k=0;k<n;k++)
{
glRasterPos2d(P[k].x,P[k].y);
Print("P%d",k);
}
// Draw curve when we have enough points
switch (mode)
{
// Continuous Bezier
case 0:
for (k=0;k<n-3;k+=3)
{
glColor3f(1,1,0);
glMap1d(GL_MAP1_VERTEX_3,0.0,1.0,3,4,(void*)(P+k));
glMapGrid1f(m,0.0,1.0);
glEvalMesh1(GL_LINE,0,m);
}
break;
// Smooth Bezier
case 1:
// First four
if (n>=4)
{
glColor3f(1,1,0);
glMap1d(GL_MAP1_VERTEX_3,0.0,1.0,3,4,(void*)P);
glMapGrid1f(m,0.0,1.0);
glEvalMesh1(GL_LINE,0,m);
}
// Subsequent triples
for (k=3;k<n-2;k+=2)
{
Point r[4];
// P0, P2 and P3 are specified points
r[0] = P[k];
r[2] = P[k+1];
r[3] = P[k+2];
// P1 is computed by reflecting P2 from previous segment
r[1].x = 2*P[k].x-P[k-1].x;
r[1].y = 2*P[k].y-P[k-1].y;
r[1].z = 2*P[k].z-P[k-1].z;
// Draw curve
glColor3f(1,1,0);
glMap1d(GL_MAP1_VERTEX_3,0.0,1.0,3,4,(void*)r);
glMapGrid1f(m,0.0,1.0);
glEvalMesh1(GL_LINE,0,m);
// Draw reflected point in red
glColor3f(1,0,0);
glBegin(GL_POINTS);
glVertex2f(r[1].x,r[1].y);
glEnd();
glRasterPos2d(r[1].x,r[1].y);Print("R%d",k-1);
}
break;
// Interpolate 4 at a time
case 2:
for (k=0;k<n-3;k+=3)
{
Point r[4];
// Transform 4 data points to 4 control points
Pmult(Mi,P+k,r);
// Draw curve
glColor3f(1,1,0);
glMap1d(GL_MAP1_VERTEX_3,0.0,1.0,3,4,(void*)r);
glMapGrid1f(m,0.0,1.0);
glEvalMesh1(GL_LINE,0,m);
// Draw control points
glColor3f(1,0,0);
glBegin(GL_POINTS);
glVertex2f(r[1].x,r[1].y);
glVertex2f(r[2].x,r[2].y);
glEnd();
glRasterPos2d(r[1].x,r[1].y);Print("R%d",k+1);
glRasterPos2d(r[2].x,r[2].y);Print("R%d",k+2);
}
break;
// B Spline 4 at a time
case 3:
for (k=0;k<n-3;k++)
{
int j;
Point r[4];
// Transform 4 data points to 4 control points (note increment is 1)
Pmult(Ms,P+k,r);
// Draw curve
glColor3f(1,1,0);
glMap1d(GL_MAP1_VERTEX_3,0.0,1.0,3,4,(void*)r);
glMapGrid1f(m,0.0,1.0);
glEvalMesh1(GL_LINE,0,m);
// Draw control points
glColor3f(1,0,0);
glBegin(GL_POINTS);
for (j=0;j<4;j++)
glVertex2f(r[j].x,r[j].y);
glEnd();
}
break;
// Cubic Natural Spline
case 4:
// Calculate (x,y,z) splines
CubicSpline((void*)P,(void*)S,0,n);
CubicSpline((void*)P,(void*)S,1,n);
CubicSpline((void*)P,(void*)S,2,n);
// Draw entire curve
glColor3f(1,1,0);
glBegin(GL_LINE_STRIP);
for (k=0;k<n-1;k++)
{
// Cardinal point
glVertex2d(P[k].x,P[k].y);
// Increment between k and k+1
for (i=1;i<m;i++)
{
double f = (double)i/m;
double g = 1-f;
double f2 = (f*f*f-f)/6;
double g2 = (g*g*g-g)/6;
double x = f*P[k+1].x + g*P[k].x + f2*S[k+1].x + g2*S[k].x;
double y = f*P[k+1].y + g*P[k].y + f2*S[k+1].y + g2*S[k].y;
double z = f*P[k+1].z + g*P[k].z + f2*S[k+1].z + g2*S[k].z;
glVertex3d(x,y,z);
}
}
// Last cardinal point
glVertex2d(P[n-1].x,P[n-1].y);
glEnd();
break;
default:
break;
}
// Display parameters
glColor3f(1,1,1);
glWindowPos2i(5,5);
Print(text[mode]);
if (n<NMAX)
Print(" Click to add point\n");
else
Print(" Click to start new curve\n");
// Render the scene and make it visible
ErrCheck("display");
glFlush();
glutSwapBuffers();
}
/////////////////////////////////////////////////////////
// Render
//
void GEMglMapGrid1f :: render(GemState *state) {
glMapGrid1f (un, u1, u2);
}
M(void, glMapGrid1f, jint un, jfloat u1, jfloat u2) {
glMapGrid1f(un, u1, u2);
}
