消息关闭
    暂无新消息!
各位大大,想问问大家关于画三角形的问题。我想画两个四棱锥组成的8面体,现在遇到的问题是单显示上面的那个四棱锥和单显示下面的那个四棱锥都可以正常显示,但要同时显示他们两个上面的那个没有问题,但下面的那个总是显示多出来几个三角形面片,找了很久都找不到问题出在哪,还请各位大大有空的话帮忙看看。万分感谢!

PS.我只用opengl画点,画线和显示三角形的算法是我自己写的,并没有采用opengl,因为我也是被别人要求不可以使用opengl直接画,所以才这样做的。
我代码的思路大致如下:
利用相似三角形原理将空间的点映射到平面上(transfertoplane函数),然后再平面上选点作为起始点终止点画线(drawLine函数),我的相机观察位置是0,0,150
我设定的两个四棱锥顶点坐标分别是:{0.0,0.0,50.0},{-30.0,30.0,0.0},{30.0,30.0,0.0},{-30.0,-30.0,0.0},{30.0,-30.0,0.0,{0.0,0.0,-50.0}

#include"glut.h"
#include<stdlib.h>
#include<math.h>
//#include<iostream>
using namespace std;
#include<string>

/* Set initial display window size  */
float winWidth=450,winHeight=450;

/* Set range for world coordinates  */
float xwcMin=-150.0,xwcMax=150.00;

float ywcMin=-150.0,ywcMax=150.00;

float zwcMin=-150.0,zwcMax=150.00;

/* Set the view coordinate and the view point*/
float X0=0.0,Y0=0.0,Z0=150.0;   //camera position

float Xref=0.0,Yref=0.0,Zref=0.0;  //get the vector N by p0 and pref, the direction of camera is -N

float Vx=0.0,Vy=1.0,Vz=0.0;  //the direction of top side of the camera

/* Set the range of camera (the coordinate limit for the clipping window*/
float xwMin=-20,ywMin=-20,xwMax=20,ywMax=20;

/* Set the position for near and far clipping planes*/
float dnear=75,dfar=225;

float rotx=0;
float roty=0;
float rotz=0;

const float piover180 = 0.0174532925f;   //*1 degree in pi standard*/

/* point in the world coordinate */
class wcPt3D
{
public:
float x,y,z;
};

class wcPt2D
{
public:
float x,y,zdepth;
};

typedef float Matrix4x4[4][4];
Matrix4x4 matComposite,directMat;
const double pi=3.14159;

typedef float Matrix3x3[3][3];
Matrix3x3 pointsonplane[4];


typedef float Matrix2x3[2][3];

//---------------------------Vector class----------------------------------//
class FVector3  
{  
public:  
    union  
    {  
        struct  
        {  
            double X, Y, Z;  
        };  
        struct  
{  
            double x, y, z;  
        };  
        double v[3];  
    };  
public:  
    FVector3(){}  
    FVector3(double x1,double y1,double z1):x(x1),y(y1),z(z1)  
    {}  
    FVector3(const FVector3& InV);  
  
    FVector3 operator^(const FVector3& V) const;  
    FVector3& Normalize();  
  
};  
  
inline  
FVector3::FVector3(const FVector3& InV)  
{  
    x = InV.x;  
    y = InV.y;  
    z = InV.z;  
}  
  
inline double appInvSqrt(double f) { return 1.f/sqrt(f); }  
  
inline FVector3&  
FVector3::Normalize()                                //vector normalize
{  
    double SquareSum = X*X + Y*Y + Z*Z;  
    if( SquareSum < 0.000001 )  
        return *this;  
    double Scale = appInvSqrt(SquareSum);  
    X *= Scale;  
    Y *= Scale;  
    Z *= Scale;  
    return *this;  
}  
  
inline FVector3   
FVector3::operator^( const FVector3& V ) const        //cross product
{  
    return FVector3(Y * V.Z - Z * V.Y, Z * V.X - X * V.Z, X * V.Y - Y * V.X );  
}  

//----------------------------------------------------------------------//
void matrix4x4SetIdentity(Matrix4x4 matIdent4x4)
{
int row,col;

for(row=0;row<4;row++)
for(col=0;col<4;col++)
matIdent4x4[row][col]=(row==col);
}

/* M2=M1*M2,premultiply m2 times m1 and store the result in m2*/
void matrix4x4PreMultiply (Matrix4x4 m1,Matrix4x4 m2)
{
int row,col;
Matrix4x4 matTemp;
  
for(row=0;row<4;row++)      // this loop is used for calculating M1*M2
for(col=0;col<4;col++)
matTemp[row][col]=m1[row][0]*m2[0][col]+m1[row][1]*m2[1][col]+m1[row][2]*m2[2][col]+m1[row][3]*m2[3][col];

for(row=0;row<4;row++)
for(col=0;col<4;col++)
m2[row][col]=matTemp[row][col];
}

void translate3D(float tx,float ty,float tz)
{
Matrix4x4 matTransl;

matrix4x4SetIdentity(matTransl);

matTransl[0][3]=tx;
matTransl[1][3]=ty;
matTransl[2][3]=tz;

matrix4x4PreMultiply(matTransl,matComposite);
}

static void LookAt(double eyeX,double eyeY,double eyeZ,double centerX,double centerY,double centerZ,double upX,double upY,double upZ)  
{  

//Matrix4x4 directMat;
matrix4x4SetIdentity(directMat);

    FVector3 fvDirect(centerX-eyeX,centerY-eyeY,centerZ-eyeZ);  //a vector point to object '-N'
    fvDirect.Normalize();  
    FVector3 fvUpD(upX,upY,upZ);                   // a vector point to the top of the camera 
    fvUpD.Normalize();  
    FVector3 fvC = fvDirect^fvUpD;        //camera right vector 'U'                
    fvC.Normalize();  
      
    FVector3 fvUp = fvC^fvDirect;         //camera top vector 'V'
    fvUp.Normalize();  
      
    fvDirect.x = -fvDirect.x;             //'z coordinator', vector 'N'
    fvDirect.y = -fvDirect.y;  
    fvDirect.z = -fvDirect.z;  

    directMat[0][0] = fvC.x;  
    directMat[0][1] = fvC.y;             // 'U'
    directMat[0][2] = fvC.z;  
    directMat[1][0] = fvUp.x;  
    directMat[1][1] = fvUp.y;            // 'V'
    directMat[1][2] = fvUp.z;  
    directMat[2][0] = fvDirect.x;  
    directMat[2][1] = fvDirect.y;        // 'N'
    directMat[2][2] = fvDirect.z;   

glTranslatef(-eyeX,-eyeY,-eyeZ);  

}  


//--------------------------------------transfer to plane-----------------------
//it works and its working principle can be confirmed in the project 'test_transfer'
float * transfertoplane(wcPt3D* verts, Matrix3x3 & v)
{
Matrix2x3 transfer;

for(int i=0;i<2;i++)
{
for(int j=0;j<3;j++)
{
transfer[i][j]=0;
}
}

for(int k=0;k<3;k++)
{
transfer[0][0]=dnear/(Z0-verts[k].z);
transfer[1][1]=dnear/(Z0-verts[k].z);

v[0][k]=transfer[0][0]*verts[k].x+transfer[0][1]*verts[k].y+transfer[0][2]*verts[k].z;  //using for find the coordinator on the screen
v[1][k]=transfer[1][0]*verts[k].x+transfer[1][1]*verts[k].y+transfer[1][2]*verts[k].z;
v[2][k]=verts[k].z;               //using for test depth
}
return *v;
}

//-----------------------drawline-----------------------------------------------//
void drawPoint(float x,float y)
{
 glPointSize(1.0f);
     glBegin(GL_POINTS);
     glColor3f(1,0,1);   //pink line
 glVertex2f(x,y);
     glEnd();
 glFlush();
}


void drawLine(float x0,float y0,float xE,float yE)
{

float dx=xE-x0,dy=yE-y0,transx,transy,k;
float xIncrement,yIncrement,x=x0,y=y0;

    k=dy/dx;

 if(xE!=x0)
 {
if(xE>x0)
{}
else 
{
transx=xE; 
xE=x0;
x0=transx;
transy=yE;
yE=y0;
y0=transy;
}
for(int i=0;i<xE-x0;i=i+0.1)
{
drawPoint(x0,y0);
x0=x0+0.1;
y0=y0+0.1*k;
}
 }
 else 
 {
 if(yE>=y0)
 {}
 else 
 {
 transy=yE;
 yE=y0;
 y0=transy;
 transx=x0;
 x0=xE;
 xE=transx;
 }
 for(int j=0;j<yE-y0;j+0.1)
 {
 drawPoint(x0,y0);
 y0=y0+0.1; 
 }
 }
}
//---------------------------------------------------------------------//
void init(void)
{
/* Set color of the display window to white*/
//glClearColor(1.0,1.0,1.0,0.0);
    matrix4x4SetIdentity(matComposite);
LookAt(X0,Y0,Z0,Xref,Yref,Zref,Vx,Vy,Vz);      //Set the camera

glMatrixMode(GL_PROJECTION); 
glFrustum(xwMin, xwMax, ywMin ,ywMax, dnear, dfar); 

}

/* scale matrix */
void scale3D(float sx,float sy,float sz,wcPt3D fixedPt)
{
Matrix4x4 matScale;
matrix4x4SetIdentity(matScale);
matScale[0][0]=sx;
matScale[0][3]=(1-sx)*fixedPt.x;
matScale[1][1]=sy;
matScale[1][3]=(1-sy)*fixedPt.y;
matScale[2][2]=sz;
matScale[2][3]=(1-sz)*fixedPt.z;

matrix4x4PreMultiply(matScale,matComposite);
}

/* rotate matrix(round x) */
void rotate3Dx(float theta)
{
Matrix4x4 matRot_x;

matrix4x4SetIdentity(matRot_x);
matRot_x[1][1]=cos(theta*piover180);
matRot_x[1][2]=-sin(theta*piover180);
matRot_x[2][1]=sin(theta*piover180);
matRot_x[2][2]=cos(theta*piover180);

matrix4x4PreMultiply(matRot_x,matComposite);
}

/* rotate matrix(round y) */
void rotate3Dy(float theta)
{
Matrix4x4 matRot_y;

matrix4x4SetIdentity(matRot_y);
matRot_y[0][0]=cos(theta*piover180);
matRot_y[0][2]=sin(theta*piover180);
matRot_y[2][0]=-sin(theta*piover180);
matRot_y[2][2]=cos(theta*piover180);

matrix4x4PreMultiply(matRot_y,matComposite);
}

/* rotate matrix(round z) */
void rotate3Dz(float theta)
{
Matrix4x4 matRot_z;

matrix4x4SetIdentity(matRot_z);
matRot_z[0][0]=cos(theta*piover180);
matRot_z[0][1]=-sin(theta*piover180);
matRot_z[1][0]=sin(theta*piover180);
matRot_z[1][1]=cos(theta*piover180);

matrix4x4PreMultiply(matRot_z,matComposite);
}

// T*[x,y,z,1]=[x',y',z',h]
void transformVerts3D(int nVerts,wcPt3D* verts)
{
int k;
float temp1,temp2;
for(k=0;k<nVerts;k++)
{
temp1=matComposite[0][0]*verts[k].x+matComposite[0][1]*verts[k].y+matComposite[0][2]*verts[k].z+matComposite[0][3];
temp2=matComposite[1][0]*verts[k].x+matComposite[1][1]*verts[k].y+matComposite[1][2]*verts[k].z+matComposite[1][3];
verts[k].z=matComposite[2][0]*verts[k].x+matComposite[2][1]*verts[k].y+matComposite[2][2]*verts[k].z+matComposite[2][3];
verts[k].x=temp1;
verts[k].y=temp2;
}
}

//-----------------------2d triangle------------------------------------------//

void triangle(wcPt2D *verts)
{
drawLine(verts[0].x,verts[0].y,verts[1].x,verts[1].y);
drawLine(verts[1].x,verts[1].y,verts[2].x,verts[2].y);
drawLine(verts[2].x,verts[2].y,verts[0].x,verts[0].y);
}

//---------------------------------------------------------------------------//

代码未完,接后面回帖

8个回答

︿ 3
现在我把display函数里planevertex1~8的顺序改成5~8,1~4问题就解决了,代码如下:

但我完全不明白为什么,哪个大神可以为我解释一下?

	planevertex5[0].x=*pb5;
    planevertex5[1].x=*(pb5+1);
    planevertex5[2].x=*(pb5+2);
    planevertex5[0].y=*(pb5+3);
    planevertex5[1].y=*(pb5+4);
    planevertex5[2].y=*(pb5+5);
    planevertex5[0].zdepth=*(pb5+6);
    planevertex5[1].zdepth=*(pb5+7);
    planevertex5[2].zdepth=*(pb5+8);

planevertex6[0].x=*pb6;
    planevertex6[1].x=*(pb6+1);
    planevertex6[2].x=*(pb6+2);
    planevertex6[0].y=*(pb6+3);
    planevertex6[1].y=*(pb6+4);
    planevertex6[2].y=*(pb6+5);
    planevertex6[0].zdepth=*(pb6+6);
    planevertex6[1].zdepth=*(pb6+7);
    planevertex6[2].zdepth=*(pb6+8);

planevertex7[0].x=*pb7;
    planevertex7[1].x=*(pb7+1);
    planevertex7[2].x=*(pb7+2);
    planevertex7[0].y=*(pb7+3);
    planevertex7[1].y=*(pb7+4);
    planevertex7[2].y=*(pb7+5);
    planevertex7[0].zdepth=*(pb7+6);
    planevertex7[1].zdepth=*(pb7+7);
    planevertex7[2].zdepth=*(pb7+8);

planevertex8[0].x=*pb8;
    planevertex8[1].x=*(pb8+1);
    planevertex8[2].x=*(pb8+2);
    planevertex8[0].y=*(pb8+3);
    planevertex8[1].y=*(pb8+4);
    planevertex8[2].y=*(pb8+5);
    planevertex8[0].zdepth=*(pb8+6);
    planevertex8[1].zdepth=*(pb8+7);
    planevertex8[2].zdepth=*(pb8+8);

planevertex1[0].x=*pb1;
    planevertex1[1].x=*(pb1+1);
    planevertex1[2].x=*(pb1+2);
    planevertex1[0].y=*(pb1+3);
    planevertex1[1].y=*(pb1+4);
    planevertex1[2].y=*(pb1+5);
    planevertex1[0].zdepth=*(pb1+6);
    planevertex1[1].zdepth=*(pb1+7);
    planevertex1[2].zdepth=*(pb1+8);

    planevertex2[0].x=*pb2;
    planevertex2[1].x=*(pb2+1);
    planevertex2[2].x=*(pb2+2);
    planevertex2[0].y=*(pb2+3);
    planevertex2[1].y=*(pb2+4);
    planevertex2[2].y=*(pb2+5);
planevertex2[0].zdepth=*(pb2+6);
planevertex2[1].zdepth=*(pb2+7);
planevertex2[2].zdepth=*(pb2+8);

    planevertex3[0].x=*pb3;
    planevertex3[1].x=*(pb3+1);
    planevertex3[2].x=*(pb3+2);
planevertex3[0].y=*(pb3+3);
planevertex3[1].y=*(pb3+4);
planevertex3[2].y=*(pb3+5);
planevertex3[0].zdepth=*(pb3+6);
planevertex3[1].zdepth=*(pb3+7);
planevertex3[2].zdepth=*(pb3+8);

    planevertex4[0].x=*pb4;
    planevertex4[1].x=*(pb4+1);
    planevertex4[2].x=*(pb4+2);
    planevertex4[0].y=*(pb4+3);
    planevertex4[1].y=*(pb4+4);
    planevertex4[2].y=*(pb4+5);
    planevertex4[0].zdepth=*(pb4+6);
    planevertex4[1].zdepth=*(pb4+7);
    planevertex4[2].zdepth=*(pb4+8);
︿ 1
              《学OpenGL编3D游戏》
                学程序编游戏之二

    《学OpenGL编3D游戏》是编程系列丛书之一。是以一个完整的3D游戏编写过程,进行程序设计的知识、技术教学。本教程由书和光盘构成。

   《学OpenGL编3D游戏》不同于传统的程序设计书籍,它重在游戏的实现方案。以一个完整的游戏为主线,用鱼骨方式讲解相关知识技术,力求可读性更好。

   《学OpenGL编3D游戏》的教学辅助系统CAI由四大块组成:

A、程序要点说明
B、程序编制演示
C、程序运行效果
D、源程序编辑


        光盘目录结构
学OpenGL编3D游戏目录下内容说明
  目录
第1 章 OpenGL的程序框架__Windows、OpenGL程序框架的建立。
第2 章 OpenGL的基本图形__在OpenGL图形界面上作一些简单的图形。
第3 章 OpenGL的组合图形__用简单图形来构成两个复杂一点的3D模型。
第4 章 摄像漫游__________有了摄像机你就可以在OpenGL场景中自由地漫游了。
第5 章 开天辟地__________在OpenGL场景中有了天空、大地、景物。
第6 章 OpenGL中显示文字__介绍了OpenGL中文字的几种显示方式。
第7 章 特殊的平面_树_____栽些树种些草,让这个OpenGL世界充满生机。
第8 章 显示3D模型________在OpenGL场景中显示3DS格式的模型。
第9 章 使用MD2动画模型___OpenGL场景中出现了活生生的人(3D动画模型)。
第10 章 使用MDL动画模型__介绍一种更先进的动画模型—3D骨骼动画。
第11章 射击、爆炸________逼真的爆炸效果,是用程序仿真爆炸的物理过程。
第12章 碰撞检测__________加入碰撞检测后,游戏才有真实的感觉。
第13章 游戏进度保存______场景(或进度)保存和调入是游戏必不可少的。
第14章 3D场景编辑________3D场景编辑,给你提供了安排山河的可能。
include 公用程序
运行程序 所有运行程序 
    学OpenGL编3D游戏运行程序在里面
  文件
TSCC.exe AVI解码器
运行须知.txt 错误解决方法
说明文档.txt 本文档
学OpenGL编3D游戏.bat 运行“学OpenGL编3D游戏”
////////////////////////////////////
如果程序编制演示的AVI不能播放,请自行安装盘上的TSCC.exe。
   从 11章射击、爆炸开始程序中用到了DirectX8.0的鼠标接口函数,如果你机器上不是装的DirectX8.0可能不能编译。请参照DirectX连接库的设置。
︿ 1
接主题,此为余下部分代码



float z_rotx=0;
float z_roty=0;
float z_rotz=0;
float sx=1;
float sy=1;
float sz=1;
float tx=0;
float ty=0;
float tz=0;
wcPt2D planevertex1[3],planevertex2[3],planevertex3[3],planevertex4[3],planevertex5[3],planevertex6[3],planevertex7[3],planevertex8[3];


void displayFcn(void)
{
float *pb1,*pb2,*pb3,*pb4,*pb5,*pb6,*pb7,*pb8;

glEnable(GL_DEPTH_TEST);

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); 

int nVerts=3;
wcPt3D verts1[3]={{-30.0,30.0,0.0},{30.0,30.0,0.0},{0.0,0.0,50.0}};     //set the polygon
wcPt3D verts2[3]={{-30.0,30.0,0.0},{-30.0,-30.0,0.0},{0.0,0.0,50.0}};
wcPt3D verts3[3]={{-30.0,-30.0,0.0},{30.0,-30.0,0.0},{0.0,0.0,50.0}};
wcPt3D verts4[3]={{30.0,-30.0,0.0},{30.0,30.0,0.0},{0.0,0.0,50.0}};
    wcPt3D verts5[3]={{-30.0,30.0,0.0},{30.0,30.0,0.0},{0.0,0.0,-50.0}};
wcPt3D verts6[3]={{-30.0,30.0,0.0},{-30.0,-30.0,0.0},{0.0,0.0,-50.0}};   
wcPt3D verts7[3]={{-30.0,-30.0,0.0},{30.0,-30.0,0.0},{0.0,0.0,-50.0}};
wcPt3D verts8[3]={{30.0,-30.0,0.0},{30.0,30.0,0.0},{0.0,0.0,-50.0}};

wcPt3D centroidPt,fixedPt;             //set the central point and the fixed point
centroidPt.x=0.0; 
centroidPt.y=0.0;
centroidPt.z=0.0;

fixedPt=centroidPt;

matrix4x4SetIdentity(matComposite);

rotate3Dx(z_rotx);                 //rotate function
rotate3Dy(z_roty);
rotate3Dz(z_rotz);
scale3D(sx,sy,sz,fixedPt);         //scale function
translate3D(tx,ty,tz);

transformVerts3D(nVerts,verts1);
transformVerts3D(nVerts,verts2);
transformVerts3D(nVerts,verts3);
transformVerts3D(nVerts,verts4);
     transformVerts3D(nVerts,verts5);
transformVerts3D(nVerts,verts6);
transformVerts3D(nVerts,verts7);
transformVerts3D(nVerts,verts8);

pb1=transfertoplane(verts1,pointsonplane[0]);
pb2=transfertoplane(verts2,pointsonplane[1]);
pb3=transfertoplane(verts3,pointsonplane[2]);
pb4=transfertoplane(verts4,pointsonplane[3]);
pb5=transfertoplane(verts5,pointsonplane[4]);
pb6=transfertoplane(verts6,pointsonplane[5]);
pb7=transfertoplane(verts7,pointsonplane[6]);
pb8=transfertoplane(verts8,pointsonplane[7]);

planevertex1[0].x=*pb1;
    planevertex1[1].x=*(pb1+1);
    planevertex1[2].x=*(pb1+2);
    planevertex1[0].y=*(pb1+3);
    planevertex1[1].y=*(pb1+4);
    planevertex1[2].y=*(pb1+5);
    planevertex1[0].zdepth=*(pb1+6);
    planevertex1[1].zdepth=*(pb1+7);
    planevertex1[2].zdepth=*(pb1+8);

    planevertex2[0].x=*pb2;
    planevertex2[1].x=*(pb2+1);
    planevertex2[2].x=*(pb2+2);
    planevertex2[0].y=*(pb2+3);
    planevertex2[1].y=*(pb2+4);
    planevertex2[2].y=*(pb2+5);
planevertex2[0].zdepth=*(pb2+6);
planevertex2[1].zdepth=*(pb2+7);
planevertex2[2].zdepth=*(pb2+8);

    planevertex3[0].x=*pb3;
    planevertex3[1].x=*(pb3+1);
    planevertex3[2].x=*(pb3+2);
planevertex3[0].y=*(pb3+3);
planevertex3[1].y=*(pb3+4);
planevertex3[2].y=*(pb3+5);
planevertex3[0].zdepth=*(pb3+6);
planevertex3[1].zdepth=*(pb3+7);
planevertex3[2].zdepth=*(pb3+8);

    planevertex4[0].x=*pb4;
    planevertex4[1].x=*(pb4+1);
    planevertex4[2].x=*(pb4+2);
    planevertex4[0].y=*(pb4+3);
    planevertex4[1].y=*(pb4+4);
    planevertex4[2].y=*(pb4+5);
    planevertex4[0].zdepth=*(pb4+6);
    planevertex4[1].zdepth=*(pb4+7);
    planevertex4[2].zdepth=*(pb4+8);

planevertex5[0].x=*pb5;
    planevertex5[1].x=*(pb5+1);
    planevertex5[2].x=*(pb5+2);
    planevertex5[0].y=*(pb5+3);
    planevertex5[1].y=*(pb5+4);
    planevertex5[2].y=*(pb5+5);
    planevertex5[0].zdepth=*(pb5+6);
    planevertex5[1].zdepth=*(pb5+7);
    planevertex5[2].zdepth=*(pb5+8);

planevertex6[0].x=*pb6;
    planevertex6[1].x=*(pb6+1);
    planevertex6[2].x=*(pb6+2);
    planevertex6[0].y=*(pb6+3);
    planevertex6[1].y=*(pb6+4);
    planevertex6[2].y=*(pb6+5);
    planevertex6[0].zdepth=*(pb6+6);
    planevertex6[1].zdepth=*(pb6+7);
    planevertex6[2].zdepth=*(pb6+8);

planevertex7[0].x=*pb7;
    planevertex7[1].x=*(pb7+1);
    planevertex7[2].x=*(pb7+2);
    planevertex7[0].y=*(pb7+3);
    planevertex7[1].y=*(pb7+4);
    planevertex7[2].y=*(pb7+5);
    planevertex7[0].zdepth=*(pb7+6);
    planevertex7[1].zdepth=*(pb7+7);
    planevertex7[2].zdepth=*(pb7+8);

planevertex8[0].x=*pb8;
    planevertex8[1].x=*(pb8+1);
    planevertex8[2].x=*(pb8+2);
    planevertex8[0].y=*(pb8+3);
    planevertex8[1].y=*(pb8+4);
    planevertex8[2].y=*(pb8+5);
    planevertex8[0].zdepth=*(pb8+6);
    planevertex8[1].zdepth=*(pb8+7);
    planevertex8[2].zdepth=*(pb8+8);


triangle(planevertex1);
triangle(planevertex2);
triangle(planevertex3);
triangle(planevertex4);
triangle(planevertex5);
triangle(planevertex6);
triangle(planevertex7);
triangle(planevertex8);

glFlush();
}

void keys(unsigned char key, int x, int y)

if (key=='z')
{
z_rotx+=10;
}
if (key=='x')
{
z_rotx-=10;

}
if (key=='c')
{
z_roty+=10;
}
if (key=='v')
{
z_roty-=10;
}
if (key=='b')
{
z_rotz+=10;
}
if (key=='n')
{
z_rotz-=10;
}
if(key=='w')
{
sx+=0.1;
sy+=0.1;
sz+=0.1;
}
if(key=='s')
{
sx-=0.1;
sy-=0.1;
sz-=0.1;
}
if(key=='i')
{
tx-=5;
}
if(key=='k')
{
tx+=5;
}
if(key=='o')
{
ty-=5;
}
if(key=='l')
{
ty+=5;
}
if(key=='p')
{
tz-=5;
}
if(key==';')
{
tz+=5;
}



if(key=='t')
{
glEnable(GL_LIGHTING);
}
if(key=='y')
{
glDisable(GL_LIGHTING);
}
if(key=='g')
{
glEnable(GL_TEXTURE_2D);
}
if(key=='h')
{
glDisable(GL_TEXTURE_2D);
}
displayFcn();
}

/* Main Function*/
void main(int argc, char ** argv)
{
// char *input1[1]; 
// int i;
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowPosition(50,50);
glutInitWindowSize(winWidth,winHeight);
glutCreateWindow("3D test");

init();

glutDisplayFunc(displayFcn);

    glutKeyboardFunc(keys);

glutMainLoop();
}
︿ 0
GLUT代表OpenGL应用工具包,英文全称为OpenGL Utility Toolkit,是一个和窗口系统无关的软件包,它由Mark Kilgard在SGI时写的。