Подскажите как нарисовать при помощи OpenGL поверхность вращения, есть параметрические уравнения для координат x(t),y(t)? Надо вращать вокруг оси 0Y, с дальнейшей целью раскрасить и вращать получившуюся картинку(по нажатию клавиш).(пишу на С++,простое приложение без использования WinAPI и MFC)
Здравствуйте, GunVan, Вы писали:
GV>Подскажите как нарисовать при помощи OpenGL поверхность вращения, есть параметрические уравнения для координат x(t),y(t)? Надо вращать вокруг оси 0Y, с дальнейшей целью раскрасить и вращать получившуюся картинку(по нажатию клавиш).(пишу на С++,простое приложение без использования WinAPI и MFC)
Вот мз моей старой ДОСовской проги. Я думаю, что ты поймешь.
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define D 256
#define NumPoly 36
#define Numpoints 20
void
conv3d2d(int &X,int &Y,float x,float y,float z)
{
X = 320 + x * D / ( z + D );
Y = 175 + (y * D / ( z + D )*35)/48;
}
float sint[360];
float cost[360];
struct Point3D{
float x,y,z;
};
struct Point2D{
int x,y;
};
struct Poly{
unsigned p1,p2,p3,color;
};
Point3D points[Numpoints];
Poly polygons[NumPoly];
void vretrace()
{
asm mov dx,3dah;
A1:
asm{
in al,dx
and al,8
jnz A1
};
A2:
asm{
in al,dx
and al,8
jz A2
};
}
void drawtriangle(int x,int y,int x1,int y1,int x2,int y2,int color)
{
int ppp[6];
ppp[0] = x;
ppp[1] = y;
ppp[2] = x1;
ppp[3] = y1;
ppp[4] = x2;
ppp[5] = y2;
setfillstyle(1,color);
setcolor(color);
fillpoly(3,ppp);
}
void init()
{
int gdriver = EGA, gmode = EGAHI,i;
initgraph(&gdriver, &gmode, "");
int P2;
for( i = 0;i < 360; i++ )
{
sint[i] = sin(i*M_PI/180);
cost[i] = cos(i*M_PI/180);
}
for( i=0; i<18;i++)
{
points[i].x = 40*cost[i*20];
points[i].y = 40*sint[i*20];
points[i].z = -70;
if( i < 17 ) P2 = i+1;
else P2 = 0;
polygons[i].p1 = P2;
polygons[i].p2 = i;
polygons[i].p3 = 18;
polygons[i].color = i%15+1;
polygons[i+18].p1 = i;
polygons[i+18].p2 = P2;
polygons[i+18].p3 = 19;
polygons[i+18].color = i%14+2;
}
points[18].x = 0;
points[18].y = 0;
points[18].z = 70;
points[19].x = 0;
points[19].y = 0;
points[19].z = -75;
}
void RotateXYZ(float &rx,float &ry,float &rz,int alpha,int beta,int gamma)
{
// ‚®ЄагЈ ®бЁ X
float x = rx;
float y = ry;
float z = rz;
ry = y*cost[alpha] - z*sint[alpha];
rz = y*sint[alpha] + z*cost[alpha];
y = ry;
z = rz;
// ‚®ЄагЈ ®бЁ Y
rx = x*cost[beta] + z*sint[beta];
rz = -x*sint[beta] + z*cost[beta];
x = rx;
z = rz;
// ‚®ЄагЈ ®бЁ Z
rx = x*cost[gamma] - y*sint[gamma];
ry = x*sint[gamma] + y*cost[gamma];
x = rx;
y = ry;
}
void main()
{
Point2D project[Numpoints];
Point3D rotatepnt[Numpoints];
int i,page = 1;
int alpha = 0,beta = 0, gamma = 0;
long v1,v2,w1,w2;
init();
do{
setactivepage(page);
setvisualpage(1 - page);
vretrace();
cleardevice();
for( i = 0;i < Numpoints; i++)
{
rotatepnt[i].x = points[i].x;
rotatepnt[i].y = points[i].y;
rotatepnt[i].z = points[i].z;
RotateXYZ(rotatepnt[i].x,rotatepnt[i].y,rotatepnt[i].z,alpha,beta,gamma);
conv3d2d(project[i].x,project[i].y,rotatepnt[i].x,rotatepnt[i].y,rotatepnt[i].z);
}
for( i = 0;i < NumPoly; i++)
{
v1 = project[polygons[i].p2].x - project[polygons[i].p1].x;
v2 = project[polygons[i].p2].y - project[polygons[i].p1].y;
w1 = project[polygons[i].p3].x - project[polygons[i].p1].x;
w2 = project[polygons[i].p3].y - project[polygons[i].p1].y;
if( (v1*w2-v2*w1) > 0 )
drawtriangle(project[polygons[i].p1].x,
project[polygons[i].p1].y,
project[polygons[i].p2].x,
project[polygons[i].p2].y,
project[polygons[i].p3].x,
project[polygons[i].p3].y,
polygons[i].color);
}
alpha++;
if( alpha == 360 ) alpha = 0;
beta++;
if( beta > 359 ) beta = 0;
// gamma -= 2;
// if( gamma < 0 ) gamma = 359;
page = 1 - page;
}while(!kbhit());
closegraph();
}
... << RSDN@Home 1.1.4 beta 3 rev. 185>>
Здравствуйте, GunVan, Вы писали:
GV>Здравствуйте, Konstantin S., Вы писали:
KS>>А вообще, советую книжку "OPENGL для профессионалов" там все подробно расписано.
KS>>Даже как строить поверхности вращения по сплайнам. К сожалению примеров кода там нет,
KS>>так что послать исходняк не смог.
GV>Прошу прощения прошлый раз забыл войти под своим именем — получился Аноним!
GV>А вот эта книга только в бумажном варианте существует или есть возможность скачать?(можно и на английском, я уже на все готов )
Насчет электронного варианта я не уверен. Надо в Гугле поискать. Книга называется "OPENGL для профессионалов", автор Френсис Хилл.
По-английски она называется так: "Computer Graphics Using OpenGL" (second edititon), Francis S.Hill.
Вот нашел одно задание в книге. А для этого задания приводится пример:
----------------------------------------------------------------------
6.4. Скелет подпрограммы создания каркасной модели для гладкой поверхности
void Mesh:: makeSurfaceMesh()
{
int i, j, numValsU = numValsV = 40;// set these
double u, v, uMin = vMin = -10.0, uMax = vMax = 10.0;
double delU = (uMax - uMin)/(numValsU - 1);
double delV = (vMax - vMin)/(numValsV - 1);
numVerts = numValsU * numValsV + 1; // total # of vertices
numFaces = (numValsU -1) * (numValsV - 1) ; // # of faces
numNorms = numVerts; // for smooth shading - one normal per vertex
pt = new Point3[numVerts]; assert(pt != NULL); // make space
face = new Face[numFaces]; assert(face != NULL);
norm = new Vector3[numNorms]; assert(norm != NULL);
for(i = 0, u = uMin; i < numValsU; i++, u += delU)
for(j = 0, v = vMin; j < numValsV; j++, v += delV)
{
int whichVert = i * numValsV + j; //index of the vertex and normal
// set this vertex: use functions X, Y, and Z
pt[whichVert].set(X(u, v),Y(u, v),Z(u, v));
// set the normal at this vertex: use functions nx, ny, nz
norm[whichVert].set(nx(u, v), ny(u, v), nz(u, v));
normalize(norm[whichVert]);
// make quadrilateral
if(i > 0 && j > 0) // when to compute next face
{
int whichFace =(i - 1) * (numValsV - 1) + (j - 1);
face[whichFace].vert = new VertexID[4];
assert(face[whichFace].vert != NULL);
face[whichFace].nVerts = 4;
face[whichFace].vert[0].vertIndex = // same as norm index
face[whichFace].vert[0].normIndex = whichVert;
face[whichFace].vert[1].vertIndex =
face[whichFace].vert[1].normIndex = whichVert - 1;
face[whichFace].vert[2].vertIndex =
face[whichFace].vert[2].normIndex = whichVert - numValsV - 1;
face[whichFace].vert[3].vertIndex =
face[whichFace].vert[3].normIndex = whichVert - numValsV;
}
}
}
А вот пример из моей еще одной проги. Тут создается цилиндр.
void init()
{
int gdriver = EGA, gmode = EGAHI,i;
initgraph(&gdriver, &gmode, "");
int P1,P2,P3,P4;
for( i = 0;i < 360; i++ )
{
sint[i] = sin(i*M_PI/180);
cost[i] = cos(i*M_PI/180);
}
for( i=0; i<18;i++)
{
points[i].x = 40*cost[i*20];
points[i].y = 40*sint[i*20];
points[i].z = -70;
points[i+18].x = 40*cost[i*20];
points[i+18].y = 40*sint[i*20];
points[i+18].z = 70;
P1 = i;
P4 = i + 18;
if( i < 17 )
{
P2 = i+1;
P3 = i+1+18;
}
else
{
P2 = 0;
P3 = 18;
}
polygons[i].p1 = P4;
polygons[i].p2 = P2;
polygons[i].p3 = P1;
polygons[i].color = i%15+1;
polygons[i+18].p1 = P4;
polygons[i+18].p2 = P3;
polygons[i+18].p3 = P2;
polygons[i+18].color = i%15+1;
polygons[i+36].p1 = P1;
polygons[i+36].p2 = P2;
polygons[i+36].p3 = 37;
polygons[i+36].color = i%14+2;
polygons[i+54].p1 = P3;
polygons[i+54].p2 = P4;
polygons[i+54].p3 = 36;
polygons[i+54].color = i%14+2;
}
points[36].x = 0;
points[36].y = 0;
points[36].z = 70;
points[37].x = 0;
points[37].y = 0;
points[37].z = -70;
}
Я думаю, что на OpenGL это перевести не сложно.
>> Есть обычай на Руси: программировать на Си. >> RSDN@Home 1.1.4 beta 3 rev. 185 >>
Здравствуйте Все! Вот что получилось насчет сабжа:
GV>Подскажите как нарисовать при помощи OpenGL поверхность вращения, есть параметрические уравнения для координат x(t),y(t)? Надо вращать вокруг оси 0Y, с дальнейшей целью раскрасить и вращать получившуюся картинку(по нажатию клавиш).(пишу на С++,простое приложение без использования WinAPI и MFC)
Еще раз повторюсь человек я начинающий! принимаются замечания и предложения по улучшению и оптимизации, если такие возникнут буду рад!
#include <GL/glut.h>
#include <math.h>
#include <iostream.h>
#define PI (3.1415926)
//const GLfloat Pi=PI;//=acos(-1);
GLfloat T=2;//параметр сферы
double delta_t=0.1,delta_r=0.1;//шаги изменения
double ANGLE0=0.0,ANGLE1=2*PI;//отрезок изменения угла поворота
double T0=-2*PI,T1=2*PI;//отрезок изменения параметра t для сл1
double route_y=0;
double route_z=0;
double route_delta=0.5;
//----------------------------------------------------------------
//сл1
double xx(double t)
{
if(t==0) return T;
else
return 2*T*sin(t/2)/t;
}
//----------------------------------------------------------------
double yy(double t)
{
if(t==0) return 0;
else
return T*T*(t-sin(t))/(2*t*t);
}
//----------------------------------------------------------------
double xn(double t)
{
if(t!=0) return T*cos(t/2)/t-2*T*sin(t/2)/(t*t);
else return 0;
} // Производная xx(t)
//----------------------------------------------------------------
double yn(double t)
{
if(t!=0) return T*T*(1-cos(t))/(2*t*t) — T*T*(t-sin(t))/(t*t*t);
else return T*T/12;
} // Производная yy(t)
//----------------------------------------------------------------
bool Normalization(double &x,double &y,double &z)
{
double len;
if((x==0) &&(y==0) &&(z==0)) return false;
len=sqrt(x*x+y*y+z*z);
x=x/len;
y=y/len;
z=z/len;
return true;
}
//----------------------------------------------------------------
void resize(int w,int h)
{
glViewport(0,0,w,h);
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho(-6,6, -6,6, 0,12);
gluLookAt( 7,0,0, 0,0,0, 0,-1,0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
}
//----------------------------------------------------------------
void init(void)
{
GLfloat ambient[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat lmodel_ambient[] = { 0.4, 0.4, 0.4, 1.0 };
GLfloat local_view[] = { 0.0 };
GLfloat position[] = { 0.0, 3.0, 2.0, 0.0 };
GLfloat position1[] = { 0.0, -3.0, -2.0, 0.0 };
glEnable(GL_DEPTH_TEST);// для работы алгоритма z-буфера
glEnable(GL_COLOR_MATERIAL);
glClearColor(1,1,1,1);
glShadeModel(GL_SMOOTH);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glLightfv(GL_LIGHT1, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT1, GL_SPECULAR, specular);
glLightfv(GL_LIGHT1, GL_POSITION, position1);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE );
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
}
//----------------------------------------------------------------
void display()
{
GLfloat no_mat[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat ambient[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat diffuse[] = { 0.1, 0.5, 0.8, 1.0 };
GLfloat specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat shininess[] = { 70.0 };
GLfloat mat_emission[] = {0.3, 0.2, 0.2, 0.0};
double t,ang;
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, no_mat);
glRotated(route_y,1,0,0 );
glRotated(route_z,0,0,1 );
glPushMatrix();
glColor3d(1,0,0);
double x,y,z;
double nx,ny,nz;
double curcos,cursin,curx,cury,curderx,curdery,curxst,curyst,curderxst,curderyst;
glBegin(GL_TRIANGLE_STRIP);//полоса из треугольников
for(t=T0;t<=T1;t+=delta_t)
{
curx=xx(t);//значение xx(t) в текущей точке t
cury=yy(t);//значение yy(t) в текущей точке t
curderx=xn(t);//значение xn(t) в текущей точке t
curdery=yn(t);//значение yn(t) в текущей точке t
if(t+delta_t<=T1)
{
curxst=xx(t+delta_t);//значение xx(t+delta_t) в текущей точке t
curyst=yy(t+delta_t);//значение yy(t+delta_t) в текущей точке t
curderxst=xn(t+delta_t);//значение xn(t+delta_t) в текущей точке t
curderyst=yn(t+delta_t);//значение yn(t+delta_t) в текущей точке t
}
else
{
curxst=xx(T1);
curyst=yy(T1);
curderxst=xn(T1);
curderyst=yn(T1);
}
for(ang=ANGLE0;ang<ANGLE1;ang+=delta_r)
{
curcos=cos(ang);
cursin=sin(ang);
x=curx*curcos;
y=cury;
z=curx*cursin;
nx=curderx*curcos;
ny=curdery;
nz=curderx*cursin;
Normalization(nx,ny,nz);
glNormal3d(nx,ny,nz);
glVertex3d(x,y,z);
x=curxst*curcos;
y=curyst;
z=curxst*cursin;
nx=curderxst*curcos;
ny=curderyst;
nz=curderxst*cursin;
Normalization(nx,ny,nz);
glNormal3d(nx,ny,nz);
glVertex3d(x,y,z);
}
ang=ANGLE1;
curcos=cos(ang);
cursin=sin(ang);
x=curx*curcos;
y=cury;
z=curx*cursin;
nx=curderx*curcos;
ny=curdery;
nz=curderx*cursin;
Normalization(nx,ny,nz);
glNormal3d(nx,ny,nz);
glVertex3d(x,y,z);
x=curxst*curcos;
y=curyst;
z=curxst*cursin;
nx=curderxst*curcos;
ny=curderyst;
nz=curderxst*cursin;
Normalization(nx,ny,nz);
glNormal3d(nx,ny,nz);
glVertex3d(x,y,z);
}
glEnd();
glutSwapBuffers();
glPopMatrix();
}
//----------------------------------------------------------------
void keys(unsigned char key, int x, int y)
{
switch (key)
{
case 'u':route_y=route_delta;break;
case 'd':route_y=-route_delta;break;
case 'l':route_z=route_delta;break;
case 'r':route_z=-route_delta;break;
case 'o':route_y=0; route_z=0;break;
}
}
//----------------------------------------------------------------
void main()
{
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(600, 600);
glutCreateWindow( "Surface of rotation" );
init();
glutIdleFunc(display);//Функция простоя
glutDisplayFunc(display);
glutReshapeFunc(resize);
glutKeyboardFunc(keys);
glutMainLoop();
}
//---------------------------------------------------------------------------
— Сильнее любви, богатства и власти —
время. Праздник жизни прекрасен. Но наступает час, и с самой лучшей
компанией приходится расставаться...
Простите что-то скрипты не сработали, поэтом текст не раскрашен, как можно было при помощи [ccode]
и рисовать имеюшийся сегмент! имхо так будет дешевле, тем более что результат не будет зависеть от количества точек вдоль OY (в случае же если мы поворачиваем всю кривую каждый раз — нам потребуется вызывать по 2 синуса и 2 косинуса на каждую такую точку)
