欢迎访问 Lu程序设计

OpenLuGl V1.0 使用说明

目  录

1 概述 [返回页首]

    OpenLuGl64.dll是一个基于OpenGL的Lu扩展动态库 ，需要MLu64.dll的支持。OpenLuGl来源于OpenFcGl，OpenFcGl是基于Forcal的扩展库。

    OpenLuGl试图输出OpenGl的大部分函数并加以扩展（目前仅进行了部分工作），使之能方便地绘制三维图形。

    OpenLuGl中的函数目前有四种：以gl开头的是OpenGl库中的标准OpenGl函数；以glu开头的是glu库中的辅助OpenGl函数；以gle开头的是为方便与OpenGl和绘图窗口交互而扩展的函数；以lg开头的是OpenLuGl扩展的实用绘图函数，目前主要是一些绘制数学函数图形的函数。OpenLuGl努力保证这些函数在运行时的安全性，即无论以何种顺序使用这些函数，程序都不会崩溃（这也是所有Lu函数应具有的特点），但用户应该知道：只有正确地使用这些函数，才能充分发挥它们的性能。充分了解每一个要使用的函数的性能是非常必要的。

    OpenLuGl中绝大多数的OpenGl函数（以gl或glu开头）的用法与在OpenGl中完全相同，但也有少数函数不一样，在使用中要主要这些差别。

    OpenLuGl中的函数参数通常为整数或实数，在使用中需要加以区分。

2 OpenGl简介 [返回页首]

    OpenGL是近几年发展起来的一个性能卓越的三维图形标准，它是在SGI等多家世界闻名的计算机公司的倡导下，以SGI的GL三维图形库为基础制定的一个通用共享的开放式三维图形标准。目前，包括Microsoft、SGI、IBM、DEC、SUN、HP等大公司都采用了OpenGL做为三维图形标准，许多软件厂商也纷纷以OpenGL为基础开发出自己的产品，其中比较著名的产品包括动画制作软件Soft Image和3D Studio MAX、仿真软件Open Inventor、VR软件World Tool Kit、CAM软件ProEngineer、GIS软ARC/INFO等等。值得一提的是，随着Microsoft公司在Windows中提供了OpenGL标准及OpenGL三维图形加速卡的推出，OpenGL已在微机中有广泛地应用，同时也为广大用户提供了在微机上使用以前只能在高性能图形工作站上运行的各种软件的机会。

3 OpenLuGl的图形输出及坐标系统 [返回页首]

3.1 OpenGL的屏幕坐标与函数自变量的变化范围

    坐标的中心在屏幕中心，X轴由左向右，Y轴由下向上，Z轴由里向外（屏幕以里为负值，屏幕以外为正值）,三个坐标轴组成右手坐标系。注意：图象必须被绘制在屏幕里面才能够看到。
    通常，屏幕坐标与函数自变量的变化范围并不一致，例如函数：z(x,y)=x+y，x取[-3.0,3.0]，y取[-3.0,3.0]，则z的取值范围为[-6.0,6.0]。可以将该函数的图象绘制在屏幕的任何位置，例如：X[0.0,10.0]，Y[0.0,10.0]，Z[-10.0,-20.0]。

3.2 用键盘移动屏幕坐标

    →：坐标原点沿X轴正向向右移动；
    ←：坐标原点沿X轴负向向左移动；
    ↑：坐标原点沿Y轴正向向上移动；
    ↓：坐标原点沿Y轴负向向下移动；
    PageUp： 坐标原点沿Z轴负向向里移动；
    PageDown：坐标原点沿Z轴正向向外移动；
    Home：坐标复位。

3.3 用键盘使图象旋转

    在OpenLuGl中设置了三个可由键盘操纵的数，这三个数可由函数gleAngle[i]获得，使用这三个数并与函数glRotated[...]配合可使图象产生旋转。

    Shift + →： 使gleAngle[1]值增加；
    Shift + ←： 使gleAngle[1]值减少；
    Shift + ↑： 使gleAngle[2]值增加；
    Shift + ↓： 使gleAngle[2]值减少；
    Shift + PageUp： 使gleAngle[3]值减少；
    Shift + PageDown： 使gleAngle[3]值增加；
    Shift + Home： 使gleAngle[i]值为0。

    在每一个绘图单元前加上以下代码，可用键盘操纵图象沿X、Y、Z轴旋转：

    glRotated[gleAngle(1),1.0,0.0,0.0]; //使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0]; //使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0]; //使图象沿Z轴旋转

3.4 看不到绘制的图象怎么办

    连续按PageUp键，使图象往屏幕里移动，即可看到图象。

4 OpenLuGl的源程序基本格式 [返回页首]

    通常，使用MLu的源程序格式书写OpenLuGl的源程序。建议使用以下基本格式：

gleDrawScene(HFor("Draw")),stop();      //（1）启动场景绘制，就退出

//... ...                               //（2）一些函数定义

initScene()=                            //（3）定义初始化函数
{
    gleClear()                          //（4）清理已经不再使用的空间

    //在这里放置初始化代码
};

Draw()=                                 //（5）场景绘制函数
{
    if[gleIsInitScene(),initScene()],   //（6）需要初始化场景时，就执行初始化函数

    glClear[],                          //（7）清除屏幕以及深度缓存
    glLoadIdentity[],                   //（8）重置视图
    glTranslated[0.0,0.0,-20.0],        //（9）移动坐标，向屏幕里移动20个单元
    glColor3d[1.0,0.0,0.0],             //（10）设置颜色
    glePrint["Hello OpenLuGl !"]        //（11）绘制英文字符串
};

    说明：

    （1）先通过函数gleDrawScene(HFor("Draw"))将场景绘制函数"Draw"的句柄告诉OpenLuGl，然后用stop()结束该模块的执行。通过场景绘制函数，OpenLuGl会执行该模块的其余部分。

    （2）可以在这里定义一些要用到的函数。

    （3）自定义初始化函数initScene()，仅在需要时定义该函数。

    （4）清理已经不再使用的空间，这些空间是以前绘图时申请的，重新绘图时，这些空间已经成为垃圾。如果有此语句，必须为初始化函数代码的第一个语句。

    （5）自定义场景绘制函数Draw()，该函数的代码会被OpenLuGl循环执行。

    （6）这句仅在设置了初始化函数时添加，如果有此语句，必须为场景绘制代码的第一个语句。其中gleIsInitScene()用于判断是否需要对场景进行初始化。

    （7）从这一句开始，场景绘制才真正开始。此语句不可缺少，必须放在真正场景绘制代码的最前面。注意glClear()与前面的gleClear()是不一样的。

    （8）、（9）、（10）、（11）语句组成了一个绘图单元。第（8）语句通常为每一个绘图单元的第一句，其功能是将绘图的起点重新设置到预定的初始位置。其余各句请参考源代码中的说明，不赘述。

5 例子 [返回页首]

5.1 一元函数图象

gleDrawScene[HFor("Scene")],stop();      //设置场景绘制函数后退出

f(x)=x*sin[x];                           //一元函数定义

Scene()=
{
    glClear[],                           //清除屏幕以及深度缓存
    glLoadIdentity[],                    //重置视图
    glTranslated[0.0,0.0,-10.0],         //移动坐标，向屏幕里移动10个单元
    glColor3d[1.0,0.0,0.0],              //设置颜色
    lgPlot[@f,-10.0,10.0,LG_AXES,-3.0,3.0,-2.0,2.0]  //绘制一元函数图象
};

5.2 二元函数图象

gleDrawScene[HFor("Scene")],stop();      //设置场景绘制函数后退出

f(x,y)=(x^2-2*x)*exp(-(x^2)-y^2-x*y);

Scene(:static,Rot)=
{
    glClear[],
    glLoadIdentity[],
    glTranslated[0.0,0.0,-20.0],
    glColor3d[0.0,1.0,0.0],              //设置颜色
    glRotated[1.0*Rot++,1.0,1.0,1.0],    //使图象连续旋转
    lgPlot3d[@f,-3.0,3.0,-3.0,3.0]
};

5.3 可用键盘移动、旋转的二元函数图象

gleDrawScene[HFor("Scene")],stop();      //设置场景绘制函数后退出

f(x,y)=sin[sqrt(x*x+y*y)];

initScene()=                             //定义初始化函数
{
    gleAngle(90.0,180.0,90.0)            //设置重置视图初始位置
};

Scene()=                                 //场景绘制函数
{
    if[gleIsInitScene(),initScene()],    //需要初始化场景时，就执行初始化函数
    glClear[],
    glColor3d[1.0,0.0,0.0],                    //设置颜色
    gleAxesAngle[],                      //显示坐标和旋转角度
    glLoadIdentity[],
    glTranslated[0.0,0.0,-20.0],
    glColor3d[0.0,1.0,0.0],              //设置颜色
    glRotated[gleAngle(1),1.0,0.0,0.0],  //使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0],  //使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0],  //使图象沿Z轴旋转
    lgPlot3d[@f,-5.0,5.0,-5.0,5.0,LG_NOMESH]
};

5.4 制作彩色旋转的金字塔和正方体

gleDrawScene[HFor("Scene")],stop();      // 设置场景绘制函数后退出

Scene(:static,yRot,xyzRot)=
{
    glClear[],                           // 清屏和清除深度缓冲区
    glLoadIdentity(),                    // 重置当前Modelview矩阵
    glTranslated(-1.5,0.0,-6.0),         // 向左移动1.5个单元、向屏幕里移动6.0个单元
    glRotated(1.0*yRot,0.0,1.0,0.0),     // 在Y轴旋转金字塔

    glBegin(GL_TRIANGLES),               // 开始绘制一个三角形
        glColor3d(1.0,0.0,0.0),          // 红
        glVertex3d( 0.0, 1.0, 0.0),      // 顶（前面）
        glColor3d(0.0,1.0,0.0),          // 绿
        glVertex3d(-1.0,-1.0, 1.0),      // 左（前面）
        glColor3d(0.0,0.0,1.0),          // 蓝
        glVertex3d( 1.0,-1.0, 1.0),      // 右（前面）
        glColor3d(1.0,0.0,0.0),          // 红
        glVertex3d( 0.0, 1.0, 0.0),      // 顶（右面）
        glColor3d(0.0,0.0,1.0),          // 蓝
        glVertex3d( 1.0,-1.0, 1.0),      // 左（右面）
        glColor3d(0.0,1.0,0.0),          // 绿
        glVertex3d( 1.0,-1.0, -1.0),     // 右（右面）
        glColor3d(1.0,0.0,0.0),          // 红

        glVertex3d( 0.0, 1.0, 0.0),      // 顶（后面）
        glColor3d(0.0,1.0,0.0),          // 绿
        glVertex3d( 1.0,-1.0, -1.0),     // 左（后面）
        glColor3d(0.0,0.0,1.0),          // 蓝
        glVertex3d(-1.0,-1.0, -1.0),     // 右（后面）
        glColor3d(1.0,0.0,0.0),          // 红
        glVertex3d( 0.0, 1.0, 0.0),      // 顶（左面）
        glColor3d(0.0,0.0,1.0),          // 蓝
        glVertex3d(-1.0,-1.0,-1.0),      // 左（左面）
        glColor3d(0.0,1.0,0.0),          // 绿
        glVertex3d(-1.0,-1.0, 1.0),      // 右（左面）
    glEnd(),                             // 完成金字塔的绘制

    glLoadIdentity(),                    // 重置当前Modelview矩阵
    glTranslated(1.5,0.0,-7.0),          // 向右移动个1.5单元向屏幕里移动7个单元
    glRotated(1.0*xyzRot,1.0,1.0,1.0),   // 在X、Y、Z轴转动正方体

    glBegin(GL_QUADS),                   // 绘制一个正方体
        glColor3d(0.0,1.0,0.0),          // 设置蓝色
        glVertex3d( 1.0, 1.0,-1.0),      // 右上（顶面）
        glVertex3d(-1.0, 1.0,-1.0),      // 左上（顶面）
        glVertex3d(-1.0, 1.0, 1.0),      // 左下（顶面）
        glVertex3d( 1.0, 1.0, 1.0),      // 右下（顶面）
        glColor3d(1.0,0.5,0.0),          // 设置橘红色
        glVertex3d( 1.0,-1.0, 1.0),      // 右上（底面）
        glVertex3d(-1.0,-1.0, 1.0),      // 左上（底面）
        glVertex3d(-1.0,-1.0,-1.0),      // 左下（底面）
        glVertex3d( 1.0,-1.0,-1.0),      // 右下（底面）

        glColor3d(1.0,0.0,0.0),          // 设置红色
        glVertex3d( 1.0, 1.0, 1.0),      // 右上（前面）
        glVertex3d(-1.0, 1.0, 1.0),      // 左上（前面）
        glVertex3d(-1.0,-1.0, 1.0),      // 左下（前面）
        glVertex3d( 1.0,-1.0, 1.0),      // 右下（前面）
        glColor3d(1.0,1.0,0.0),          // 设置黄色
        glVertex3d( 1.0,-1.0,-1.0),      // 右上（后面）
        glVertex3d(-1.0,-1.0,-1.0),      // 左上（后面）
        glVertex3d(-1.0, 1.0,-1.0),      // 左下（后面）
        glVertex3d( 1.0, 1.0,-1.0),      // 右下（后面）

        glColor3d(0.0,0.0,1.0),          // 设置蓝色
        glVertex3d(-1.0, 1.0, 1.0),      // 右上（左面）
        glVertex3d(-1.0, 1.0,-1.0),      // 左上（左面）
        glVertex3d(-1.0,-1.0,-1.0),      // 左下（左面）
        glVertex3d(-1.0,-1.0, 1.0),      // 右下（左面）
        glColor3d(1.0,0.0,1.0),          // 设置紫蓝色
        glVertex3d( 1.0, 1.0,-1.0),      // 右上（右面）
        glVertex3d( 1.0, 1.0, 1.0),      // 左上（右面）
        glVertex3d( 1.0,-1.0, 1.0),      // 左下（右面）
        glVertex3d( 1.0,-1.0,-1.0),      // 右下（右面）
    glEnd(),                             // 完成正方体绘制
    yRot=yRot+0.2,                       // 增加三角形的旋转变量
    xyzRot=xyzRot-0.15                   // 减小矩形的旋转变量
};

5.5 晶体

/////////////////////////////////////////////////////////////////////
///////  请修改用户定义部分。若没有特殊的需要，其他部分无需修改
/////////////////////////////////////////////////////////////////////

//#LOAD{"dll\OpenLugl64"}            //本程序由OpenLuGl64.dll提供支持

gleDrawScene(HFor("Scene")),stop();   //启动场景绘制，就退出

//让图形随鼠标移动。factor为比例因子，factor越大则移动幅度越大。factor=0进行初始化。
luglFollowMouse(factor:x,y,xx,yy,xxx,yyy,static,luglFollowMouse,xMouse,yMouse)=
{
    if[!factor,luglFollowMouse=0,return(0)],
    if[gleGetMouseMsg(WM_LBUTTONDOWN,&x,&y),luglFollowMouse=1,xMouse=x,yMouse=y],
    gleGetWindowSize[&xxx,&yyy],
    if[luglFollowMouse,gleGetMouseMsg(WM_MOUSEMOVE,&xx,&yy),gleAngle[1,gleAngle(1)+(yy-yMouse)/yyy*factor],gleAngle[2,gleAngle(2)+(xx-xMouse)/xxx*factor]],
    if[gleGetMouseMsg(WM_LBUTTONUP,&xx,&yy),luglFollowMouse=0],
    glRotated[gleAngle(1),1.0,0.0,0.0],     //使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0],     //使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0]      //使图象沿Z轴旋转
};

//x,y,z为要获得的屏幕坐标，需要引用参数&调用。
//i,j,k为点阵坐标。
//a,b,c,Alpha,Beta,Gamma为点阵的6个参数。
//规定：点阵原点即屏幕原点，点阵a轴即屏幕x轴，点阵b轴在屏幕x,y轴决定的平面内。
luglTransCrystalAxis(x,y,z,i,j,k,a,b,c,Alpha,Beta,Gamma:_Alpha,_Beta,_Gamma,m)=
{
    _Alpha=Alpha/180*3.1415926, _Beta=Beta/180*3.1415926, _Gamma=Gamma/180*3.1415926,
    x=i*a+j*b*cos(_Gamma)+k*c*cos(_Beta),
    m=[cos(_Alpha)^2+cos(_Beta)^2]/[1+cos(_Gamma)],
    y=j*b*sin(_Gamma)+k*c*sqrt[m-cos(_Beta)^2],
    z=k*c*sqrt[1-m]
};

//绘制连接两个点阵点的线段。
luglCrystalLine(i1,j1,k1,i2,j2,k2,a,b,c,Alpha,Beta,Gamma:x,y,z)=
{
    glBegin(GL_LINES),
        luglTransCrystalAxis(&x,&y,&z,i1,j1,k1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
        luglTransCrystalAxis(&x,&y,&z,i2,j2,k2,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
    glEnd()
};

//绘制点阵平面，按逆时针输入坐标。
luglCrystalQuads(i1,j1,k1,i2,j2,k2,i3,j3,k3,i4,j4,k4,a,b,c,Alpha,Beta,Gamma:x,y,z)=
{
    glBegin(GL_QUADS),
        luglTransCrystalAxis(&x,&y,&z,i1,j1,k1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
        luglTransCrystalAxis(&x,&y,&z,i2,j2,k2,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
        luglTransCrystalAxis(&x,&y,&z,i3,j3,k3,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
        luglTransCrystalAxis(&x,&y,&z,i4,j4,k4,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
    glEnd()
};

///////////////////////////////////////////////////////////////////////////////////////////
// 用 户 定 义 开 始
///////////////////////////////////////////////////////////////////////////////////////////

DrawCellEdge(a,b,c,Alpha,Beta,Gamma,EdgeR,EdgeG,EdgeB)=       //绘制晶胞晶棱的函数
{
    glColor3d[EdgeR,EdgeG,EdgeB],

    luglCrystalLine(0,0,0,0,1,0,a,b,c,Alpha,Beta,Gamma),
    luglCrystalLine(0,1,0,0,1,1,a,b,c,Alpha,Beta,Gamma),
    luglCrystalLine(0,1,1,0,0,1,a,b,c,Alpha,Beta,Gamma),
    luglCrystalLine(0,0,1,0,0,0,a,b,c,Alpha,Beta,Gamma),
    luglCrystalLine(0,0,0,1,0,0,a,b,c,Alpha,Beta,Gamma),
    luglCrystalLine(1,0,0,1,0,1,a,b,c,Alpha,Beta,Gamma),
    luglCrystalLine(1,0,1,0,0,1,a,b,c,Alpha,Beta,Gamma),
    luglCrystalLine(1,0,0,1,1,0,a,b,c,Alpha,Beta,Gamma),
    luglCrystalLine(1,1,0,0,1,0,a,b,c,Alpha,Beta,Gamma),
    luglCrystalLine(1,1,0,1,1,1,a,b,c,Alpha,Beta,Gamma),
    luglCrystalLine(1,0,1,1,1,1,a,b,c,Alpha,Beta,Gamma),
    luglCrystalLine(1,1,1,0,1,1,a,b,c,Alpha,Beta,Gamma)
};

DrawCellDot(::Ball)=                                          //绘制顶点的函数
{
    gluSphere[Ball,0.1,10,10]
};

DrawCellApex(a,b,c,Alpha,Beta,Gamma,ApexR,ApexG,ApexB:x,y,z)= //绘制晶胞顶点
{
    glColor3d[ApexR,ApexG,ApexB],

    luglTransCrystalAxis(&x,&y,&z,0,0,0,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
    luglTransCrystalAxis(&x,&y,&z,0,0,1,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
    luglTransCrystalAxis(&x,&y,&z,0,1,0,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
    luglTransCrystalAxis(&x,&y,&z,0,1,1,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
    luglTransCrystalAxis(&x,&y,&z,1,0,0,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
    luglTransCrystalAxis(&x,&y,&z,1,0,1,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
    luglTransCrystalAxis(&x,&y,&z,1,1,0,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
    luglTransCrystalAxis(&x,&y,&z,1,1,1,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z]
};

//绘制晶胞（晶棱及顶点）。不要在绘制晶棱及顶点的函数中使用显示列表。
//a,b,c,Alpha,Beta,Gamma：晶胞参数。EdgeR,EdgeG,EdgeB：晶棱颜色。ApexR,ApexG,ApexB：顶点颜色。
//该函数在显示列表中绘制图形，返回一个显示列表序号。
//在初始化场景时调用该函数，在场景绘制代码中执行该函数返回的显示列表。
DrawCrystalCell(a,b,c,Alpha,Beta,Gamma,EdgeR,EdgeG,EdgeB,ApexR,ApexG,ApexB:x,y,z,list)=
{
    list=glGenLists[1],
    glNewList[list,GL_COMPILE],
        DrawCellEdge(a,b,c,Alpha,Beta,Gamma,EdgeR,EdgeG,EdgeB), //绘制晶胞晶棱
        DrawCellApex(a,b,c,Alpha,Beta,Gamma,ApexR,ApexG,ApexB), //绘制晶胞顶点
    glEndList[],
    list
};

initScene(::MouseSpeed,Centre,CellX,CellY,CellZ,                //初始化函数
CellA,CellB,CellC,CellAlpha,CellBeta,CellGamma,EdgeR,EdgeG,EdgeB,ApexR,ApexG,ApexB,Ball)=
{
    gleClear(),
    Ball=gluNewQuadric[], gluQuadricDrawStyle[Ball,GLU_FILL],gluQuadricNormals[Ball,GLU_SMOOTH],
    gleAxis(0.0,0.0,-12.0),gleAngle(0.0,0.0,0.0),                          //设置图形初始位置
    MouseSpeed=2.0,                                                        //鼠标移动速度
    Centre=0,                                                              //0：点阵原点在屏幕中心；其他值：点阵中心在屏幕中心
    CellX=3, CellY=3, CellZ=3,                                             //X,Y,Z方向晶胞个数
    ApexR=1.0, ApexG=0.0, ApexB=1.0,                                       //晶胞顶点颜色
    CellA=1.0, CellB=1.0 ,CellC=1.0, CellAlpha=90.0, CellBeta=90.0, CellGamma=120.0, //晶胞参数
    EdgeR=0.0, EdgeG=1.0, EdgeB=0.0                                        //晶胞晶棱颜色
};

///////////////////////////////////////////////////////////////////////////////////////////
// 用 户 定 义 结 束
///////////////////////////////////////////////////////////////////////////////////////////

Scene(:i,j,k,x,y,z:listDrawCrystalCell,MouseSpeed,Centre,CellX,CellY,CellZ,
    CellA,CellB,CellC,CellAlpha,CellBeta,CellGamma,EdgeR,EdgeG,EdgeB,ApexR,ApexG,ApexB)=
{
    if{ gleIsInitScene(),             //需要初始化场景时，就执行初始化函数
        initScene(),
        listDrawCrystalCell=DrawCrystalCell(CellA,CellB,CellC,CellAlpha,CellBeta,CellGamma,EdgeR,EdgeG,EdgeB,ApexR,ApexG,ApexB),
        luglFollowMouse(0)
    },

    if{ gleVirtualKey(116),           //按F5时，重置参数
        gleVirtualKey(116,false),
        gleReSetPara
            {   "鼠标移动速度", &MouseSpeed,
                "0：点阵原点在屏幕中心；其他值：点阵中心在屏幕中心", &Centre,
                "X方向晶胞个数", &CellX,
                "Y方向晶胞个数", &CellY,
                "Z方向晶胞个数", &CellZ,
                "晶胞参数之 a", &CellA,
                "晶胞参数之 b", &CellB,
                "晶胞参数之 c", &CellC,
                "晶胞参数之 α", &CellAlpha,
                "晶胞参数之 β", &CellBeta,
                "晶胞参数之 γ", &CellGamma,
                "晶胞晶棱颜色之 Red", &EdgeR,
                "晶胞晶棱颜色之 Green", &EdgeG,
                "晶胞晶棱颜色之 Blue", &EdgeB,
                "晶胞顶点颜色之 Red", &ApexR,
                "晶胞顶点颜色之 Green", &ApexG,
                "晶胞顶点颜色之 Blue", &ApexB
            },
        glDeleteLists(listDrawCrystalCell,1),
        listDrawCrystalCell=DrawCrystalCell(CellA,CellB,CellC,CellAlpha,CellBeta,CellGamma,EdgeR,EdgeG,EdgeB,ApexR,ApexG,ApexB)
    },

    glClear[],                    //清除屏幕以及深度缓存

    glColor3d[1.0,0.0,0.0],
    gleAxesAngle[],               //显示屏幕坐标及旋转角度

    glLoadIdentity[],             //重置视图
    luglFollowMouse(MouseSpeed),  //鼠标跟随

    //按F4时，显示帮助
    if[gleVirtualKey(115),gleVirtualKey(115,false),gleMessageBox("按下鼠标左键，图形将随鼠标移动，放开鼠标左键，图形停止移动。\r\n按F5进行参数设置。","图形演示说明",64)],

    if[Centre,glTranslated(-CellX/2.0,-CellY/2.0,-CellZ/2.0)],
    i=0,
    while{  i<CellX,j=0,
            while{  j<CellY,k=0,
                    while{  k<CellZ,
                            luglTransCrystalAxis(&x,&y,&z,i,j,k,CellA,CellB,CellC,CellAlpha,CellBeta,CellGamma),
                            glTranslated[x,y,z],             //移动坐标
                            glCallList[listDrawCrystalCell], //绘制图形
                            glTranslated[-x,-y,-z],          //恢复坐标
                            k++
                    },
                    j++
            },
            i++
    }
};

6 显示列表与实体模块 [返回页首]

    OpenGl显示列表是一组预先存储起来的OpenGl命令。显示列表可以在任何地方被调用，并按顺序立即执行。显示列表是经过编译的，因而执行效率比较高。

    要应用显示列表，首先应创建一个显示列表（创建显示列表要在初始化函数中进行），由glNewList()函数和glEndList()函数来完成。执行显示列表的函数是glCallList()函数或glCallLists()函数。管理和使用显示列表的函数还有glListBase()、glGenLists()和glDeleteLists()等函数。

    使用显示列表的例子：[1]、[2]、[3]。

    尽管显示列表给应用程序提供了一个提高整体性能的机制，但并不能任意使用显示列表。因为启动显示列表需要一定的开销，如果这种开销不能被执行命令的开销所抵消，那就适得其反了。显示列表可以应用于：

    第一，由大量的数据构造的几何模型，且是多次被调用或是几何模型要发生运行。

    第二，较高维数的矩阵操作。在图形学算法中，需要涉及大量的矩阵运算，特别是矩阵求逆运算。

    第三，光栅位图、图像和纹理操作。应用显示列表可调整像素数据，使其适合硬件处理的格式。

    第四，光照计算。光照具有十分复杂的数学运算，如果场景中不同材质的物体较多且需要变化，把材质放入显示列表中，能发挥显示列表的优势。

    第五，OpenGl使用库中标准二次曲面、Bezier曲线及曲面、NURBS曲线及曲面的绘制等等。

    使用显示列表要注意以下事项：

    第一，显示列表中所有函数的参数是当前的，不会受今后变化的影响。

    第二，封装在显示列表中的变换操作会对后继绘图产生影响。

    第三，显示列表不可对其进行外部干预。

    第四，显示列表需要精心管理。

    第五，不能在显示列表中使用的函数有：glIsList()，glGenLists()，glDeleteLists()，glFeedbackBuffer()，glSelectBuffer()，glRenderMode()，glFlush()，glFinish()，glIsEnabled()，glGet()。

    实体模块是用OpenGl命令绘制任意实体的MLu的模块源程序。模块写好后，一般不需改动，仅在需要时调用即可。显然，在模块中使用显示列表创建实体是非常方便的。

    例如，下面的程序可作为模块来使用，可在任意的场景绘制单元中加入鼠标支持：

//让图形随鼠标移动。factor为比例因子，factor越大则移动幅度越大。factor=0进行初始化。
luglFollowMouse(factor:x,y,xx,yy,xxx,yyy,static,luglFollowMouse,xMouse,yMouse)=
{
    if[!factor,luglFollowMouse=0,return(0)],
    if[gleGetMouseMsg(WM_LBUTTONDOWN,&x,&y),luglFollowMouse=1,xMouse=x,yMouse=y],
    gleGetWindowSize[&xxx,&yyy],
    if[luglFollowMouse,gleGetMouseMsg(WM_MOUSEMOVE,&xx,&yy),gleAngle[1,gleAngle(1)+(yy-yMouse)/yyy*factor],gleAngle[2,gleAngle(2)+(xx-xMouse)/xxx*factor]],
    if[gleGetMouseMsg(WM_LBUTTONUP,&xx,&yy),luglFollowMouse=0],
    glRotated[gleAngle(1),1.0,0.0,0.0],     //使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0],     //使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0]      //使图象沿Z轴旋转
};

    再如，下面的模块可用在晶体图的绘制中：

//x,y,z为要获得的屏幕坐标，需要引用参数&调用。
//i,j,k为点阵坐标。
//a,b,c,Alpha,Beta,Gamma为点阵的6个参数。
//规定：点阵原点即屏幕原点，点阵a轴即屏幕x轴，点阵b轴在屏幕x,y轴决定的平面内。
luglTransCrystalAxis(x,y,z,i,j,k,a,b,c,Alpha,Beta,Gamma:_Alpha,_Beta,_Gamma,m)=
{
    _Alpha=Alpha/180*3.1415926, _Beta=Beta/180*3.1415926, _Gamma=Gamma/180*3.1415926,
    x=i*a+j*b*cos(_Gamma)+k*c*cos(_Beta),
    m=[cos(_Alpha)^2+cos(_Beta)^2]/[1+cos(_Gamma)],
    y=j*b*sin(_Gamma)+k*c*sqrt[m-cos(_Beta)^2],
    z=k*c*sqrt[1-m]
};

//绘制连接两个点阵点的线段。
luglCrystalLine(i1,j1,k1,i2,j2,k2,a,b,c,Alpha,Beta,Gamma:x,y,z)=
{
    glBegin(GL_LINES),
        luglTransCrystalAxis(&x,&y,&z,i1,j1,k1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
        luglTransCrystalAxis(&x,&y,&z,i2,j2,k2,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
    glEnd()
};

//绘制点阵平面，按逆时针输入坐标。
luglCrystalQuads(i1,j1,k1,i2,j2,k2,i3,j3,k3,i4,j4,k4,a,b,c,Alpha,Beta,Gamma:x,y,z)=
{
    glBegin(GL_QUADS),
        luglTransCrystalAxis(&x,&y,&z,i1,j1,k1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
        luglTransCrystalAxis(&x,&y,&z,i2,j2,k2,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
        luglTransCrystalAxis(&x,&y,&z,i3,j3,k3,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
        luglTransCrystalAxis(&x,&y,&z,i4,j4,k4,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
    glEnd()
};

//绘制简单晶胞（晶棱及顶点）。顶点由自定义函数DrawCellDot()绘制，该函数在调用模块中定义，被自动调用，不要在该函数中使用显示列表。
//a,b,c,Alpha,Beta,Gamma：晶胞参数。EdgeR,EdgeG,EdgeB：晶棱颜色。ApexR,ApexG,ApexB：顶点颜色。
//该函数在显示列表中绘制图形，返回一个显示列表序号。
//在初始化场景时调用该函数，在场景绘制代码中执行该函数返回的显示列表。
luglDrawCrystalPCell(a,b,c,Alpha,Beta,Gamma,EdgeR,EdgeG,EdgeB,ApexR,ApexG,ApexB:x,y,z,list)=
{
    list=glGenLists[1],
    glNewList[list,GL_COMPILE],
        //绘制点阵单元
        glColor3d[EdgeR,EdgeG,EdgeB],
        glBegin(GL_LINES),
            luglTransCrystalAxis(&x,&y,&z,0,0,0,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,0,1,0,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,0,1,0,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,0,1,1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,0,1,1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,0,0,1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,0,0,1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,0,0,0,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,0,0,0,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,1,0,0,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,1,0,0,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,1,0,1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,1,0,1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,0,0,1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,1,0,0,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,1,1,0,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,1,1,0,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,0,1,0,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,1,1,0,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,1,1,1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,1,0,1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,1,1,1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,1,1,1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
            luglTransCrystalAxis(&x,&y,&z,0,1,1,a,b,c,Alpha,Beta,Gamma),glVertex3d(x,y,z),
        glEnd(),

        //绘制顶点
        glColor3d[ApexR,ApexG,ApexB],
        luglTransCrystalAxis(&x,&y,&z,0,0,0,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
        luglTransCrystalAxis(&x,&y,&z,0,0,1,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
        luglTransCrystalAxis(&x,&y,&z,0,1,0,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
        luglTransCrystalAxis(&x,&y,&z,0,1,1,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
        luglTransCrystalAxis(&x,&y,&z,1,0,0,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
        luglTransCrystalAxis(&x,&y,&z,1,0,1,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
        luglTransCrystalAxis(&x,&y,&z,1,1,0,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
        luglTransCrystalAxis(&x,&y,&z,1,1,1,a,b,c,Alpha,Beta,Gamma),glTranslated[x,y,z],DrawCellDot(),glTranslated[-x,-y,-z],
    glEndList[],
    list
};

7 函数概述 [返回页首]

    OpenLuGl试图输出OpenGl的绝大部分函数并加以扩展（目前仅进行了部分工作），使之能方便地绘制三维图形。

    OpenLuGl中的函数目前有四种：以gl开头的是OpenGl库中的标准OpenGl函数；以glu开头的是glu库中的辅助OpenGl函数；以gle开头的是为方便与OpenGl和绘图窗口交互而扩展的函数；以lg开头的是OpenLuGl扩展的实用绘图函数，目前主要是一些绘制数学函数图形的函数。OpenLuGl努力保证这些函数在运行时的安全性，即无论以何种顺序使用这些函数，程序都不会崩溃（这也是所有Lu二级函数应具有的特点），但用户应该知道：只有正确地使用这些函数，才能充分发挥它们的性能。充分了解每一个要使用的函数的性能是非常必要的。

    根据函数的使用位置，OpenLuGl函数可分为三类：进行场景绘制的函数，用于初始化场景的函数，可在任意位置使用的函数。场景绘制函数 具有循环执行的特点，显然可用于场景的初始化；而初始化函数仅在切换场景时执行一次，通常不能用在场景绘制函数之中。

    OpenLuGl中绝大多数的OpenGl函数（以gl或glu开头）的用法及功能与在OpenGl中完全相同，但也有少数函数不一样，在使用中要主要这些差别。 其中，函数列表中标记为“有扩展”的函数为与OpenGl函数的用法及功能完全相同且有所扩展；标记为“有区别”的函数与OpenGl函数的功能完全相同，但用法有区别。

8 gl函数 ：OpenGl函数 [返回页首]

[返回本类函数列表] [返回页首] glClear[]或glClear[Mask]：清除屏幕以及深度缓存

Mask：整数，工作方式。

Bitwise OR operators of masks that indicate the buffers to be cleared. The four masks are as follows.

Mask	Buffer to be Cleared
GL_COLOR_BUFFER_BIT	The buffers currently enabled for color writing.
GL_DEPTH_BUFFER_BIT	The depth buffer.
GL_ACCUM_BUFFER_BIT	The accumulation buffer.
GL_STENCIL_BUFFER_BIT	The stencil buffer.

通常，要把该函数设为场景绘制代码的第一个语句。

[例子]

[返回本类函数列表] [返回页首] glLoadIdentity[]或glLoadIdentity[... ...]：重置视图

glLoadIdentity[]：将X、Y、Z轴移到屏幕的指定位置（该位置由gleAxis(SetX,SetY,SetZ)指定）。

glLoadIdentity[... ...]：将X、Y、Z轴移到屏幕的中心位置。

通常在每一个图象绘制之前都要进行此项操作。

[例子]

[返回本类函数列表] [返回页首] glTranslated[x,y,z]：移动坐标（参数为实数）

注意：当移动时，不是以屏幕的中心为起点而是以当前所在位置为起点进行移动。
通常在每一个图象绘制之前都要进行此项操作。

[例子]

[返回本类函数列表] [返回页首] glColor3d[r,g,b]：设置颜色（参数为实数）

三个参数分别是红、绿、蓝的颜色强度值，其取值范围是从0.0到1.0。
一些特殊的颜色：[1.0,0.0,0.0]：红色、[0.0,1.0,0.0]：绿色、[0.0,0.0,1.0]：蓝色、[0.0,0.0,0.0]：黑色、[1.0,1.0,1.0]：白色

[例子]

[返回本类函数列表] [返回页首] glBegin[mode]：开始绘图

glBegin[mode]与glEnd[]必须成对使用，glBegin[mode]表示一个绘图单元的开始，glEnd[]表示一个绘图单元的结束。这一对函数使您能够绘制任意的图形。
在glBegin[mode]与glEnd[]之间，一般用glVertex3d[...]函数设置绘图点，也可包括glColor3d[r,g,b]设置颜色等函数。mode的取值及意义如下：

GL_POINTS：表示绘制一系列独立的点。
GL_LINES：每两点相连成为线段，因此，在glBegin[i]与glEnd[]之间点的个数必须是2的倍数。
GL_LINE_LOOP：封闭线段。
GL_LINE_STRIP：顶点相连成为折线。
GL_TRIANGLES：每三点相连成为一个三角形，因此，在glBegin[i]与glEnd[]之间点的个数必须是3的倍数。
GL_TRIANGLE_STRIP：相连的三角形带。
GL_TRIANGLE_FAN：相连的三角形扇。
GL_QUADS：每四点相连成为一个四边形，因此，在glBegin[i]与glEnd[]之间点的个数必须是4的倍数。
GL_QUAD_STRIP：相连的四边形带。
GL_POLYGON：绘制简单、凸多边形的边界。

该函数可能返回如下运行错误：

1：glBegin[mode]与glEnd[]没有成对使用。
2：参数mode非法。

[例子]

[返回本类函数列表] [返回页首] glEnd[]：结束绘图

glBegin[mode]与glEnd[]必须成对使用，glBegin[mode]表示一个绘图单元的开始，glEnd[]表示一个绘图单元的结束。

该函数可能返回如下运行错误：

1：glBegin[mode]与glEnd[]没有成对使用。

[例子]

[返回本类函数列表] [返回页首] glVertex3d[X,Y,Z]：设置三维绘图点（参数为实数）

X,Y,Z设置了屏幕坐标系中的一点。

注意：一般，图形的绘制从顶点开始，要按逆时针方向绘制。

[例子]

[返回本类函数列表] [返回页首] glRotated[Angle,Xvector,Yvector,Zvector]：使对象围绕轴进行旋转 （参数为实数）

Angle为旋转角度，Xvector,Yvector和Zvector一起表示哪一个向量将发生旋转。如果使用(1.0,0.0,0.0)这意味着描述一个向量将沿X轴向右旋转一个单元；如果使用(-1.0,0.0,0.0)这意味着描述一个向量将沿X轴向左旋转一个单元。

[例子]

[返回本类函数列表] [返回页首] glPointSize[size]：定义点的尺寸（参数为实数）

设置点的宽度（整数，以象素为单位）。参数size必须大于0.0，缺省时为1.0。若size<=0.0，取size=1.0。

[例子]

gleDrawScene[HFor("Scene")],stop();      //设置场景绘制函数后退出

Scene(:i)=
{
    glClear[],                           //清除屏幕以及深度缓存
    glColor3d[1.0,0.0,0.0],              //设置颜色为红色
    gleAxesAngle[],                      //显示坐标和旋转角度
    glLoadIdentity[],                    //重置视图
    glTranslated[0.0,0.0,-20.0],         //移动坐标，向屏幕里移动20个单元
    glRotated[gleAngle(1),1.0,0.0,0.0],  //可由键盘控制使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0],  //可由键盘控制使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0],  //可由键盘控制使图象沿Z轴旋转

    // 绘制一系列大小尺寸不同的点（以象素为基本扩展单元）
    glColor3d[0.0,1.0,0.0],              //设置颜色为绿色
    i=1,
    while{i<=10,
        glPointSize(i*2.0),              //定义点的尺寸
        glBegin(0),
        glVertex3d(-10.0+i*2,0.0,0.0),
        glEnd(),
        i++
        }
};

[返回本类函数列表] [返回页首] glLineWidth[width]：设置线宽（参数为实数）

设置线宽（整数，以象素为单位）。参数width必须大于0.0，缺省时为1.0。若width<=0.0，取width=1.0。

[例子]

gleDrawScene[HFor("Scene")],stop();      //设置场景绘制函数后退出

Scene()=
{
    glClear[],                           //清除屏幕以及深度缓存
    glColor3d[1.0,0.0,0.0],              //设置颜色为红色
    gleAxesAngle[],                      //显示坐标和旋转角度
    glLoadIdentity[],                    //重置视图
    glTranslated[0.0,0.0,-20.0],         //移动坐标，向屏幕里移动20个单元
    glRotated[gleAngle(1),1.0,0.0,0.0],  //可由键盘控制使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0],  //可由键盘控制使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0],  //可由键盘控制使图象沿Z轴旋转

    // 绘制三条不同线型的线段
    glEnable (GL_LINE_STIPPLE),
    glLineStipple (2, 1*16*16+1),        /* 点线 */
    glLineWidth (5.0),                   //设置线段的宽度为 5
    glBegin(GL_LINES),
        glColor3d(1.0,0.0,0.0),
        glVertex3d(-10.0,4.0,0.0),
        glVertex3d( 10.0,4.0,0.0),
    glEnd(),

    glLineStipple (1, 16*16-1),          /* 虚线 */
    glLineWidth (3.0),                   //设置线段的宽度为 3
    glBegin(GL_LINES),
        glColor3d(1.0,1.0,0.0),
        glVertex3d(-10.0,2.0,0.0),
        glVertex3d( 10.0,2.0,0.0),
    glEnd(),

    glLineStipple(3,16*16*16+12*16*16+4*16+7),/* 虚点线 */
    glLineWidth (1.0),                   //设置线段的宽度为 1
    glBegin(GL_LINES),
        glColor3d(0.0,1.0,0.0),
        glVertex3d(-10.0,-2.0,0.0),
        glVertex3d( 10.0,-2.0,0.0),
    glEnd(),

    glEnable (GL_LINE_STIPPLE)
};

[返回本类函数列表] [返回页首] glLineStipple[factor,pattern]：设置线的虚点模式

设置线为当前的虚点模式。参数pattern是一系列的16位数（0或1），它重复地赋给所指定的线。其中每一位代表一个象素，且从低位开始，1表示用当前颜色绘制一个象素（或比例因子指定的个数），0表示当前不绘制，只移动一个象素位（或比例因子指定的个数）。参数factor是个比例因子，它用来拉伸pattern中的元素，即重复绘制1或移动0，比如，factor为2，则碰到1时就连续绘制2次，碰到0时连续移动2个单元。factor的大小范围限制在1到256之间。在绘制虚点线之前必须先启动一下，即调用函数glEnable(GL_LINE_STIPPLE);若不用，则调用glDisable(GL_LINE_STIPPLE)关闭。

该函数可能返回如下运行错误：1、参数不符合要求。

[例子]

gleDrawScene[HFor("Scene")],stop();      //设置场景绘制函数后退出

Scene()=
{
    glClear[],                           //清除屏幕以及深度缓存
    glColor3d[1.0,0.0,0.0],              //设置颜色为红色
    gleAxesAngle[],                      //显示坐标和旋转角度
    glLoadIdentity[],                    //重置视图
    glTranslated[0.0,0.0,-20.0],         //移动坐标，向屏幕里移动20个单元
    glRotated[gleAngle(1),1.0,0.0,0.0],  //可由键盘控制使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0],  //可由键盘控制使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0],  //可由键盘控制使图象沿Z轴旋转

    // 绘制三条不同线型的线段
    glEnable (GL_LINE_STIPPLE),
    glLineStipple (2, 1*16*16+1),        /* 点线 */
    glBegin(GL_LINES),
        glColor3d(1.0,0.0,0.0),
        glVertex3d(-10.0,4.0,0.0),
        glVertex3d( 10.0,4.0,0.0),
    glEnd(),

    glLineStipple (1, 16*16-1),          /* 虚线 */
    glBegin(GL_LINES),
        glColor3d(1.0,1.0,0.0),
        glVertex3d(-10.0,2.0,0.0),
        glVertex3d( 10.0,2.0,0.0),
    glEnd(),

    glLineStipple(3,16*16*16+12*16*16+4*16+7),/* 虚点线 */
    glBegin(GL_LINES),
        glColor3d(0.0,1.0,0.0),
        glVertex3d(-10.0,-2.0,0.0),
        glVertex3d( 10.0,-2.0,0.0),
    glEnd(),
    glDisable(GL_LINE_STIPPLE)
};

[返回本类函数列表] [返回页首] glEnable[cap]：设置OpenGL的各种功能

与glDisable(cap)配合使用，先用glEnable[cap]设置OpenGL的功能，不用时，用glDisable(cap)取消这种功能。
例如：glEnable(GL_LINE_STIPPLE)：启用虚点模式。

The glEnable and glDisable functions enable and disable various OpenGL graphics capabilities. Use glIsEnabled or glGet to determine the current setting of any capability.

Both glEnable and glDisable take a single argument, cap, which can assume one of the following values:

[例子]

[返回本类函数列表] [返回页首] glDisable[cap]：取消OpenGL的各种功能

与glEnable(cap)配合使用，先用glEnable[cap]设置OpenGL的功能，不用时，用glDisable(cap)取消这种功能。
例如：glDisable(GL_LINE_STIPPLE)：取消虚点模式。

[例子]

[返回本类函数列表] [返回页首] glPolygonMode[face,mode]：多边形模式设置

控制多边形指定面的绘制模式。参数face为GL_FRONT、GL_BACK或GL_FRONT_AND_BACK；参数mode为GL_POINT、GL_LINE或GL_FILL，分别表示绘制轮廓点式多边形、轮廓线式多边形或全填充式多边形。缺省时，绘制的是正反面全填充式多边形。

该函数可能返回如下运行错误：1、参数不符合要求；

[例子]

gleDrawScene[HFor("Scene")],stop();                  //设置场景绘制函数后退出

f(x,y)=(x^2-2*x)*exp(-(x^2)-y^2-x*y);

Scene(:x,static,rot)=
{
    glClear[],
    glColor3d[1.0,0.0,0.0],                          //设置颜色
    gleAxesAngle[],                                  //显示坐标和旋转角度
    glLoadIdentity[],
    glTranslated[0.0,0.0,-35.0],
    glColor3d[0.0,1.0,0.0],                          //设置颜色
    glRotated[90.0,1.0,0.0,0.0],                     //使图象沿X轴旋转90度
    glRotated[gleAngle(1),1.0,0.0,0.0],              //可由键盘控制使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0],              //可由键盘控制使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0],              //可由键盘控制使图象沿Z轴旋转

    {
        x=5*sin[rot*1.0],
        glTranslated[-11.0,x,x],
        glPolygonMode[GL_FRONT,GL_POINT],            //多边形模式设置
        lgPlot3d[@f,-x,x,-x,x,LG_NOAXES,LG_NOMESH],
        glTranslated[11.0,x/2.0,x/2.0],
        glPolygonMode[GL_BACK,GL_LINE],              //多边形模式设置
        lgPlot3d[@f,-x,x,-x,x,LG_NOAXES,LG_NOMESH]
    },

    {
        x=5*sin[rot*1.0],
        glTranslated[11.0,x/2.0,x/2.0],
        glPolygonMode[GL_FRONT_AND_BACK,GL_FILL],    //多边形模式设置
        lgPlot3d[@f,-x,x,-x,x,LG_NOAXES,LG_NOMESH]
    },
    rot=rot+0.05                                     //速度控制
};

[返回本类函数列表] [返回页首] glClearColor[r,g,b,Alpha]：设置屏幕清屏的颜色

r,g,b三个参数分别是红、绿、蓝的颜色强度值，其取值范围是从0到1。
Alpha值与透明度有关。

[例子]

gleDrawScene(HFor("Draw")),stop();      //启动场景绘制，就退出

initScene()=                            //定义初始化函数
{
    glClearColor(0.0,1.0,0.0,1.0)       //设置屏幕清屏的颜色
};

Draw()=                                 //场景绘制函数
{
    if[gleIsInitScene(),initScene()],   //需要初始化场景时，就执行初始化函数

    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glTranslated[-4.0,0.0,-10.0],       //移动坐标
    glColor3d[1.0,0.0,0.0],             //设置颜色
    glePrint["Hello OpenLuGl !"]        //绘制英文字符串
};

[返回本类函数列表] [返回页首] glCallList(i)：执行显示列表

i为显示列表的序号。

[例子]

[返回本类函数列表] [返回页首] glListBase(i)：设置显示列表序列的基序号

i为显示列表序列的基序号。

[例子]

[返回本类函数列表] [返回页首] glCallLists("abc... ...")或glCallLists(n1,n2,... ...)：执行显示列表序列

glCallLists("abc... ...")：只有一个字符串参数时，字符串中的每一个字符代表一个显示列表，该显示列表序号与基序号（由glListBase(i)设置）之差等于该字符的ASCII值。

glCallLists(n1,n2,... ...)：多个整数参数时，每一个参数值等于该参数代表的显示列表序号与基序号（由glListBase(i)设置）之差。

该函数可能返回如下运行错误：1、不可识别参数。2、内存错误。

[例子]

gleDrawScene(HFor("Draw")),stop();      //启动场景绘制，就退出

initScene(:a,r,m,n:AA,Ball)=            //定义初始化函数
{
    Ball=gluNewQuadric[],               //创建二次曲面对象
    gluQuadricDrawStyle[Ball,GLU_FILL], //设置二次曲面绘制模式
    gluQuadricNormals[Ball,GLU_SMOOTH], //设置二次曲面法线信息

    a=0.5,r=0.2,m=8,n=8,
    AA=glGenLists[6],
    glNewList[AA+2,GL_COMPILE],         //绘正方形
        glBegin(GL_LINES),
            glVertex3d(-a,a,a),glVertex3d(-a,-a,a),
            glVertex3d(-a,-a,a),glVertex3d(a,-a,a),
            glVertex3d(a,-a,a),glVertex3d(a,a,a),
            glVertex3d(a,a,a),glVertex3d(-a,a,a),
            glVertex3d(-a,a,-a),glVertex3d(a,a,-a),
            glVertex3d(a,a,-a),glVertex3d(a,-a,-a),
            glVertex3d(a,-a,-a),glVertex3d(-a,-a,-a),
            glVertex3d(-a,-a,-a),glVertex3d(-a,a,-a),
            glVertex3d(-a,a,a),glVertex3d(-a,a,-a),
            glVertex3d(-a,-a,a),glVertex3d(-a,-a,-a),
            glVertex3d(a,-a,a),glVertex3d(a,-a,-a),
            glVertex3d(a,a,a),glVertex3d(a,a,-a),
        glEnd(),
    glEndList[],
    glNewList[AA+5,GL_COMPILE],         //绘正方形顶点的球
        glTranslated[-a,-a,-a],    gluSphere[Ball,r,m,n],
        glTranslated[2*a,0.0,0.0], gluSphere[Ball,r,m,n],
        glTranslated[0.0,2*a,0.0], gluSphere[Ball,r,m,n],
        glTranslated[-2*a,0.0,0.0],gluSphere[Ball,r,m,n],
        glTranslated[0.0,0.0,2*a], gluSphere[Ball,r,m,n],
        glTranslated[0.0,-2*a,0.0],gluSphere[Ball,r,m,n],
        glTranslated[2*a,0.0,0.0], gluSphere[Ball,r,m,n],
        glTranslated[0.0,2*a,0.0], gluSphere[Ball,r,m,n],
    glEndList[]
};

Draw(::AA)=                             //场景绘制函数
{
    if[gleIsInitScene(),initScene()],   //需要初始化场景时，就执行初始化函数

    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glRotated[gleAngle(1),1.0,0.0,0.0], //使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0], //使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0], //使图象沿Z轴旋转
    glTranslated[0.0,0.0,-10.0],        //移动坐标
    glColor3d[1.0,0.0,0.0],             //设置颜色
    glListBase[AA],                     //设置显示列表序列的基序号
    glCallLists[2,5]                    //执行显示列表序列

};

[返回本类函数列表] [返回页首] glGenLists(n)：创建一个或多个连续的显示列表，返回显示列表的基序号

n为显示列表的个数，n>=1。若返回值为0，表示创建失败。

[例子]

[返回本类函数列表] [返回页首] glNewList(i,mode)：建立显示列表，并编译和执行显示列表

i为显示列表的序号。mode为工作模式，mode=GL_COMPILE时，仅进行编译；mode=GL_COMPILE_AND_EXECUTE时，编译并执行显示列表。

该函数必须与glEndList()成对使用。

不要用该函数对同一个显示列表创建多次，这将引起混乱和不安全。

[例子]

gleDrawScene(HFor("Draw")),stop();      //启动场景绘制，就退出

initScene(:a,r,m,n:AA,Ball)=            //定义初始化函数
{
    Ball=gluNewQuadric[],               //创建二次曲面对象
    gluQuadricDrawStyle[Ball,GLU_FILL], //设置二次曲面绘制模式
    gluQuadricNormals[Ball,GLU_SMOOTH], //设置二次曲面法线信息

    a=0.5,r=0.2,m=8,n=8,
    AA=glGenLists[1],
    glNewList[AA,GL_COMPILE],
        glBegin(GL_LINES),             //绘正方形
            glVertex3d(-a,a,a),glVertex3d(-a,-a,a),
            glVertex3d(-a,-a,a),glVertex3d(a,-a,a),
            glVertex3d(a,-a,a),glVertex3d(a,a,a),
            glVertex3d(a,a,a),glVertex3d(-a,a,a),
            glVertex3d(-a,a,-a),glVertex3d(a,a,-a),
            glVertex3d(a,a,-a),glVertex3d(a,-a,-a),
            glVertex3d(a,-a,-a),glVertex3d(-a,-a,-a),
            glVertex3d(-a,-a,-a),glVertex3d(-a,a,-a),
            glVertex3d(-a,a,a),glVertex3d(-a,a,-a),
            glVertex3d(-a,-a,a),glVertex3d(-a,-a,-a),
            glVertex3d(a,-a,a),glVertex3d(a,-a,-a),
            glVertex3d(a,a,a),glVertex3d(a,a,-a),
        glEnd(),
        glTranslated[-a,-a,-a], gluSphere[Ball,r,m,n], //绘正方形顶点的球
        glTranslated[2*a,0.0,0.0], gluSphere[Ball,r,m,n],
        glTranslated[0.0,2*a,0.0], gluSphere[Ball,r,m,n],
        glTranslated[-2*a,0.0,0.0],gluSphere[Ball,r,m,n],
        glTranslated[0.0,0.0,2*a], gluSphere[Ball,r,m,n],
        glTranslated[0.0,-2*a,0.0],gluSphere[Ball,r,m,n],
        glTranslated[2*a,0.0,0.0], gluSphere[Ball,r,m,n],
        glTranslated[0.0,2*a,0.0], gluSphere[Ball,r,m,n],
    glEndList[]
};

Draw(::AA)=                             //场景绘制函数
{
    if[gleIsInitScene(),initScene()],   //需要初始化场景时，就执行初始化函数

    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glRotated[gleAngle(1),1.0,0.0,0.0], //使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0], //使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0], //使图象沿Z轴旋转
    glTranslated[0.0,0.0,-10.0],        //移动坐标
    glColor3d[1.0,0.0,0.0],             //设置颜色
    glCallList[AA]                      //绘制图形
};

[返回本类函数列表] [返回页首] glEndList()：结束建立显示列表

该函数必须与glNewList()成对使用。

[例子]

[返回本类函数列表] [返回页首] glVertex2d(X,Y)：设置二维绘图点

X,Y设置了屏幕二维坐标系中的一点。

[例子]

gleDrawScene(HFor("Draw")),stop();      //启动场景绘制，就退出

Draw(::AA)=                             //场景绘制函数
{
    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glTranslated[0.0,0.0,-2.0],         //移动坐标
    glColor3d[1.0,0.0,0.0],             //设置颜色

    glPolygonMode(GL_FRONT_AND_BACK,GL_LINE),

    glBegin(GL_POLYGON),                //绘四边形
        glVertex2d(-0.3,0.3),
        glEdgeFlag(false),
        glVertex2d(-0.1,-0.1),
        glEdgeFlag(true),
        glVertex2d(0.0,-0.1),
        glVertex2d(0.3,0.3),
    glEnd(),

    glBegin(GL_POLYGON),                //绘四边形
        glVertex2d(-0.1,-0.1),
        glVertex2d(-0.2,-0.4),
        glVertex2d(0.2,-0.4),
        glEdgeFlag(false),
        glVertex2d(0.0,-0.1),
        glEdgeFlag(true),
    glEnd()
};

[返回本类函数列表] [返回页首] glEdgeFlag(bool)：设置边的可见性

如果bool为真，则边是可见的；如果bool为假，则边是不可见的。

通常边的可见性不发生变化，除非再一次用不同的参数调用该函数。

[例子]

[返回本类函数列表] [返回页首] glPushMatrix()：将当前矩阵压入堆栈

glPushMatrix()与glPopMatrix()要成对使用。

[例子]

gleDrawScene(HFor("Draw")),stop();      //启动场景绘制，就退出

Draw()=                                 //场景绘制函数
{
    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glTranslated[-4.0,0.0,-10.0],       //移动坐标
    glColor3d[1.0,0.0,0.0],             //设置颜色
    glPushMatrix(),                     //将当前矩阵压入堆栈
    glePrint["Hello OpenLuGl !"],       //绘制英文字符串
    glPopMatrix(),                      //将当前矩阵弹出堆栈
    glTranslated[0.0,-2.0,0.0],         //移动坐标
    glScaled(0.5,1.0,1.0),              //缩放变换
    glePrint["Hello OpenLuGl !"]        //绘制英文字符串
};

[返回本类函数列表] [返回页首] glPopMatrix()：将当前矩阵弹出堆栈

glPushMatrix()与glPopMatrix()要成对使用。

[例子]

[返回本类函数列表] [返回页首] glScaled(sx,sy,sz)：缩放变换

sx,sy,sz分别表示沿X,Y,Z轴的缩放因子。

[例子]

[返回本类函数列表] [返回页首] glDeleteLists(list,range)：删除一组连续的显示列表

list为第一个要删除的显示列表。range为要删除的显示列表数目。

[例子]

9 glu函数 ：Glu函数 [返回页首]

[返回本类函数列表] [返回页首] gluNewQuadric()：创建二次曲面对象

返回一个二次曲面对象指针。在特定的函数中，可通过该指针访问到该二次曲面对象。二次曲面对象不用时要及时用函数delete(p)删除。

[例子]

gleDrawScene(HFor("Draw")),stop();      //启动场景绘制，就退出

initScene(::a)=                         //定义初始化函数
{
    a=gluNewQuadric[],                  //创建二次曲面对象
    gluQuadricDrawStyle[a,GLU_FILL],    //设置二次曲面绘制模式
    gluQuadricNormals[a,GLU_SMOOTH]     //设置二次曲面法线信息
};

Draw(::a)=                              //场景绘制函数
{
    if[gleIsInitScene(),initScene()],   //需要初始化场景时，就执行初始化函数

    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glTranslated[0.0,0.0,-10.0],        //移动坐标
    glColor3d[1.0,0.0,0.0],             //设置颜色
    gluSphere[a,0.5,20,20]              //绘制球
};

[返回本类函数列表] [返回页首] gluQuadricDrawStyle(aa,drawStyle)：设置二次曲面绘制模式

指针aa标识二次曲面对象。drawStyle为绘制模式。

该函数可能返回如下运行错误：1、无效的二次曲面对象指针。

The desired draw style. The following values are valid.

Value	Meaning
GLU_FILL	Quadrics are rendered with polygon primitives. The polygons are drawn in a counterclockwise fashion with respect to their normals (as defined with gluQuadricOrientation).
GLU_LINE	Quadrics are rendered as a set of lines.
GLU_SILHOUETTE	Quadrics are rendered as a set of lines, except that edges separating coplanar faces will not be drawn.
GLU_POINT	Quadrics are rendered as a set of points.

[例子]

[返回本类函数列表] [返回页首] gluQuadricNormals(aa,normals)：设置二次曲面法线信息

指针aa标识二次曲面对象。normals标识二次曲面法线信息。

该函数可能返回如下运行错误：1、无效的二次曲面对象指针。

The desired type of normals. The following values are valid.

Value	Meaning
GLU_NONE	No normals are generated.
GLU_FLAT	One normal is generated for every facet of a quadric.
GLU_SMOOTH	One normal is generated for every vertex of a quadric. This is the default value.

[例子]

[返回本类函数列表] [返回页首] gluSphere(aa,radius,slices,stacks)：绘制球

指针aa标识二次曲面对象（球）。radius为球的半径。slices,stacks为经线和纬线的线圈数。

该函数可能返回如下运行错误：1、无效的二次曲面对象指针。

[例子]

[返回本类函数列表] [返回页首] gluQuadricOrientation(aa,orientation)： 设置二次曲面插值计算的方向

指针aa标识二次曲面对象。orientation表示二次曲面插值计算的方向。orientation=GLU_OUTSIDE表示二次曲面的法线是自曲面向外的；orientation=GLU_INSIDE表示二次曲面的法线是指向二次曲面的。

该函数可能返回如下运行错误：1、无效的二次曲面对象指针。

[例子]（略）

[返回本类函数列表] [返回页首] gluQuadricTexture(aa,textureCoords)： 设置二次曲面是否生成纹理坐标

指针aa标识二次曲面对象。textureCoords表示是否为二次曲面生成纹理坐标。textureCoords为真表示生成纹理坐标，否则不生成纹理坐标。

该函数可能返回如下运行错误：1、无效的二次曲面对象指针。

[例子]（略）

[返回本类函数列表] [返回页首] gluCylinder(aa,baseRadius,topRadius,height,slices,stacks)： 绘制圆柱、圆锥或台锥

指针aa标识二次曲面对象。baseRadius,topRadius表示台锥体底面半径和顶面半径。height表示台锥的高。slices,stacks为经线和纬线的线圈数。

该函数可能返回如下运行错误：1、无效的二次曲面对象指针。

[例子]

gleDrawScene(HFor("Draw")),stop();       //启动场景绘制，就退出

Draw(:a)=                                //场景绘制函数
{
    glClear[],                           //清除屏幕以及深度缓存
    glLoadIdentity[],                    //重置视图
    glColor3d[1.0,0.0,0.0],              //设置颜色

    a=gluNewQuadric[],                   //创建二次曲面对象
    gluQuadricDrawStyle[a,GLU_FILL],     //设置二次曲面绘制模式
    gluQuadricNormals[a,GLU_SMOOTH],     //设置二次曲面法线信息

    glTranslated[-6.0,0.0,-20.0],        //移动坐标
    gluSphere[a,0.5,20,20],              //绘制球

    glTranslated[3.0,0.0,0.0],           //移动坐标
    gluCylinder[a,2.0,1.0,3.0,20,20],    //绘制台锥

    glTranslated[5.0,0.0,0.0],           //移动坐标
    gluDisk[a,0.5,2.0,20,20],            //绘制圆环

    glTranslated[5.0,0.0,0.0],           //移动坐标
    gluPartialDisk[a,0.5,2.0,20,20,10.0,80.0] //绘制扇形
};

[返回本类函数列表] [返回页首] gluDisk(aa,innerRadius,outerRadius,slices,loops)： 绘制圆盘或圆环

指针aa标识二次曲面对象。innerRadius,outerRadius表示圆环的内径和外径。slices,loops表示径向的线圈数和周向的等分直线数目。

该函数可能返回如下运行错误：1、无效的二次曲面对象指针。

[例子]

[返回本类函数列表] [返回页首] gluPartialDisk(aa,innerRadius,outerRadius,slices,loops,startAngle,sweepAngle)： 绘制扇形

指针aa标识二次曲面对象。innerRadius,outerRadius表示扇形的内径和外径。lices,loops表示径向的线圈数和周向的等分直线数目。startAngle表示起始角度。sweepAngle表示扇形的张开角度。

该函数可能返回如下运行错误：1、无效的二次曲面对象指针。

[例子]

10 gle函数 ：OpenLuGl扩展函数 [返回页首]

[返回本类函数列表] [返回页首] gleWorkDrawScene[HFor("rFor")] 或 gleWorkDrawScene[scene,HFor("rFor")]：场景绘制函数

gleWorkDrawScene将场景绘制函数"rFor"的句柄传送给OpenLuGl64.dll，"rFor"是一个表达式的名称。scene是由函数gleNewScene申请的场景指针。

该函数可能返回如下运行错误：1、参数个数非法；2：非法的场景指针；3：非法的表达式句柄。

注意：如果没有通过gleSetWindowMode给OpenLuGl窗口指定一个父窗口，必须手动关闭该函数打开的OpenLuGl窗口。

[例子]

gleWorkDrawScene(HFor("Draw")),stop();  //启动场景绘制，就退出

Draw()=                                 //场景绘制函数
{
    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glTranslated[-5.0,0.0,-15.0],       //移动坐标
    glColor3d[1.0,0.0,0.0],             //设置颜色
    glePrint["Hello OpenLuGl !"]        //绘制英文字符串
};

[返回本类函数列表] [返回页首] gleDrawScene[HFor("rFor")] 或 gleDrawScene[scene,HFor("rFor")]：场景绘制函数

gleDrawScene将场景绘制函数"rFor"的句柄传送给OpenLuGl64.dll，"rFor"是一个表达式的名称。scene是由函数gleNewScene申请的场景指针。

该函数可能返回如下运行错误：1、参数个数非法；2：非法的场景指针；3：非法的表达式句柄。

注意：该函数打开的绘图窗口会被OpenLuGl自动关闭。

[例子]

[例子]

[返回本类函数列表] [返回页首] gleNewScene["aaa"]：申请场景

字符串"aaa"是场景的窗口类的名称。每一个场景对应着一个窗口类。该函数返回一个场景指针，用在场景绘制函数gleWorkDrawScene或gleDrawScene中。场景不用时，须用函数gleDeleteScene销毁。

该函数可能返回如下运行错误：1、非法的字符串地址；2：字符串太长，应小于80个字符。

[例子]

SetScene(:static,a,free)=             //设置场景绘制函数后退出
{
    if[free,gleDeleteScene(a),return(0)], //销毁表达式时销毁场景
    a=gleNewScene["aaa"],             //申请新场景
    gleDrawScene[a, HFor("Scene")],   //设置新场景
    gleDrawScene[HFor("Draw")],       //设置默认场景
    stop()
};

f(x,y)=(x^2-2*x)*exp(-x*x-y^2-x*y);

Scene(:static,rot)=                   //场景绘制函数
{
    glClear[],
    glLoadIdentity[],
    glTranslated[0.0,0.0,-20.0],
    glColor3d[0.0,1.0,0.0],           //设置颜色
    glRotated[1.0*rot++,1.0,1.0,1.0], //使图象连续旋转
    lgPlot3d[@f,-3.0,3.0,-3.0,3.0]
};

initScene()=                          //定义初始化函数
{
    gleAngle(90.0,180.0,90.0),        //设置重置视图初始位置
    gleSetWorkMode[false]             //计时器模式
};

Draw()=                               //场景绘制函数
{
    if[gleIsInitScene(),initScene()], //需要初始化场景时，就执行初始化函数
    glClear[],                        //清除屏幕以及深度缓存
    glLoadIdentity[],                 //重置视图
    glTranslated[-5.0,0.0,-15.0],     //移动坐标
    glColor3d[1.0,0.0,0.0],           //设置颜色
    glePrint["Hello OpenLuGl !"]      //绘制英文字符串
};

[返回本类函数列表] [返回页首] gleDeleteScene[scene]：销毁场景

销毁场景scene（场景指针），该场景是由函数gleNewScene申请的。

[例子]

[返回本类函数列表] [返回页首] gleSetWorkMode[mode]：设置工作模式

若mode为真，设置为快速模式；若mode为假，设置为计时器模式。按F3可在快速模式和计时器模式之间进行切换。

[例子]

[返回本类函数列表] [返回页首] gleAxesAngle[]：显示坐标和旋转角度

[例子]

[返回本类函数列表] [返回页首] gleAxisRate(x)：设置坐标移动的速率

键盘操纵屏幕坐标移动速率的缺省值是0.1，可用该函数重新设置坐标移动的速率。

[例子]

gleDrawScene(HFor("Draw")),stop();      //启动场景绘制，就退出

initScene()=                            //定义初始化函数
{
    gleAxisRate(0.5)                    //设置坐标移动的速率
};

Draw()=                                 //场景绘制函数
{
    if[gleIsInitScene(),initScene()],   //需要初始化场景时，就执行初始化函数

    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glTranslated[-5.0,0.0,-15.0],       //移动坐标
    glColor3d[1.0,0.0,0.0],             //设置颜色
    glePrint["Hello OpenLuGl !"]        //绘制英文字符串
};

[返回本类函数列表] [返回页首] gleAngle(i)：获得由键盘操纵的旋转角度

在OpenLuGl64.dll中设置了三个可由键盘操纵的数，这三个数可由函数gleAngle[i]获得，使用这三个数并与函数glRotated[...]配合可使图象产生旋转。

Shift + →：使gleAngle[1]值增加；
Shift + ←：使gleAngle[1]值减少；
Shift + ↑：使gleAngle[2]值增加；
Shift + ↓：使gleAngle[2]值减少；
Shift + PageUp： 使gleAngle[3]值减少；
Shift + PageDown：使gleAngle[3]值增加；
Shift + Home：使gleAngle[i]值为0。

在每一个绘图单元前加上以下代码，可用键盘操纵图象沿X、Y、Z轴旋转：
glRotated[gleAngle(1),1.0,0.0,0.0]; //使图象沿X轴旋转。
glRotated[gleAngle(2),0.0,1.0,0.0]; //使图象沿Y轴旋转。
glRotated[gleAngle(3),0.0,0.0,1.0]; //使图象沿Z轴旋转。

[例子]

[返回本类函数列表] [返回页首] gleAngleRate(x)：键盘操纵图象旋转的速率

键盘操纵图象旋转的速率的缺省值是0.5，可用该函数重新设置图象旋转的速率。

[例子]

gleDrawScene(HFor("Draw")),stop();      //启动场景绘制，就退出

initScene()=                            //定义初始化函数
{
    gleAngleRate(1.0)                   //设置图象旋转的速率
};

Draw()=                                 //场景绘制函数
{
    if[gleIsInitScene(),initScene()],   //需要初始化场景时，就执行初始化函数

    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glRotated[gleAngle(1),1.0,0.0,0.0], //使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0], //使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0], //使图象沿Z轴旋转
    glTranslated[-5.0,0.0,-15.0],       //移动坐标
    glColor3d[1.0,0.0,0.0],             //设置颜色
    glePrint["Hello OpenLuGl !"]        //绘制英文字符串
};

[返回本类函数列表] [返回页首] glePrintCn["我的 OpenLu & OpenGL !"]：输出中文字符串

该函数速度很慢，但能用来输出汉字和英文。

该函数可能返回如下运行错误：1、字符串地址错误。

[例子]

gleDrawScene(HFor("Draw")),stop();      //启动场景绘制，就退出

Draw()=                                 //场景绘制函数
{
    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glTranslated[-5.0,0.0,-15.0],       //移动坐标
    glColor3d[1.0,0.0,0.0],             //设置颜色
    glePrintCn["我的 OpenLu & OpenGL !"]//绘制中文字符串
};

[返回本类函数列表] [返回页首] glePrint["abc 123 !!!"]：输出英文字符串

该函数速度很快，但不能用来输出汉字。

该函数可能返回如下运行错误：1、字符串地址错误。

[例子]

[返回本类函数列表] [返回页首] gleVirtualKey[n]或gleVirtualKey[n,bool]：键盘状态函数

gleVirtualKey[n]： 获取键盘上键的状态，n为键盘代码，0<=n<256。当键按下时该函数返回1（逻辑真），否则返回0（逻辑假）。

gleVirtualKey[n,bool]：设置键盘上键的状态，n为键盘代码，0<=n<256。将键盘代码设为逻辑值bool。

该函数可能返回如下运行错误：1、键盘代码非法。2、参数不符合要求。

例子：

gleDrawScene[HFor("Scene")],stop();          //设置场景绘制函数后退出

f(x,y)=sin[sqrt(x*x+y*y)];

Scene(:x,static,rot)=
{
    glClear[],
    glColor3d[1.0,0.0,0.0],                  //设置颜色
    gleAxesAngle[],                          //显示坐标和旋转角度
    glLoadIdentity[],
    glTranslated[0.0,0.0,-35.0],
    glColor3d[0.0,1.0,0.0],                  //设置颜色
    glRotated[90.0,1.0,0.0,0.0],             //使图象沿X轴旋转90度
    glRotated[gleAngle(1),1.0,0.0,0.0],      //可由键盘控制使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0],      //可由键盘控制使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0],      //可由键盘控制使图象沿Z轴旋转

    x=10*sin[rot*1.0],
    lgPlot3d[@f,-x,x,-x,x,LG_NOAXES,LG_NOMESH],
    glTranslated[-11.0,0.0,0.0],
    lgPlot3d[@f,-x,x,-x,x,LG_NOAXES,LG_NOMESH],
    glTranslated[22.0,0.0,0.0],
    lgPlot3d[@f,-x,x,-x,x,LG_NOAXES,LG_NOMESH],

    if[!gleVirtualKey(17),rot=rot+0.01]      //键盘控制：按Ctrl键可以暂停动画
};

附: 键盘码常量定义

[返回本类函数列表] [返回页首] gleCreatePrintCnList[str]：创建中文字符串显示列表

将中文字符串str存入显示列表并返回该显示列表的句柄n。返回值为0表示创建失败。创建成功后可以用glePrintCnList[p]显示字符串。调用delete(p)可释放 显示列表所占的空间。
通常在绘图代码中，首先启动OpenLuGl窗口，然后在窗口的初始化代码（该部分代码在窗口启动后仅执行一次）中使用该函数。在场景绘制代码中使用glePrintcnList[p]显示字符串。

[例子]

gleWorkDrawScene(HFor("Draw")),stop();              //启动场景绘制，就退出

Draw(:p)=                                           //场景绘制函数
{
    glClear[],                                      //清除屏幕以及深度缓存
    glLoadIdentity[],                               //重置视图
    glTranslated[-5.0,0.0,-15.0],                   //移动坐标
    glColor3d[1.0,0.0,0.0],                         //设置颜色
    p=gleCreatePrintCnList["I love 中文字符串！"],   //创建中文字符串显示列表
    glePrintCnList[p]                               //显示存储在列表中的中文字符串
};

[例子]

[返回本类函数列表] [返回页首] glePrintCnList[i]：显示存储在列表中的中文字符串

n为整数，标识中文字符串显示列表。该函数的速度比glPrintCn["..."]要快。通常在绘图代码中，首先启动OpenLuGl窗口，然后在窗口的初始化代码（该部分代码在窗口启动后仅执行一次）中使用gleCreatPrintCnList[str]创建中文字符串显示列表；在场景绘制代码（该部分代码被循环执行）中使用glePrintcnList[i]显示中文字符串。

该函数可能返回如下运行错误：1、无法显示列表；2、无法找到指定的显示列表。

[例子]

gleDrawScene(HFor("Scene")),stop[];                 //启动绘图窗口，然后stop退出

initScene(::cn1,cn2,cn3)=
{
    cn1=gleCreatePrintCnList["I love 中文字符串！"], //将三个字符串存入显示列表
    cn2=gleCreatePrintCnList["使用显示列表可以快速地显示中文！"],
    cn3=gleCreatePrintCnList["可以旋转的 OpenLuGl 字体！"]
};

Scene(::cn1,cn2,cn3)=
{
    if[gleIsInitScene(),initScene()],               //需要初始化场景时，就执行初始化函数

    glClear[],
    glColor3d[1.0,0.0,0.0],                         //设置颜色
    gleAxesAngle[],                                 //显示坐标和旋转角度

    glLoadIdentity[],
    glTranslated[-8.0,1.0,-15.0],
    glePrintCnList[cn1],                            //显示存储在列表中的中文字符串

    glLoadIdentity[],
    glTranslated[-8.0,0.0,-15.0],
    glePrintCnList[cn2],                            //显示存储在列表中的中文字符串

    glLoadIdentity[],
    glTranslated[-8.0,-2.0,-15.0],
    glColor3d[0.0,1.0,0.0],                         //设置颜色
    glRotated[gleAngle(1),1.0,0.0,0.0],             //使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0],             //使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0],             //使图象沿Z轴旋转
    glePrintCnList[cn3]                             //显示存储在列表中的中文字符串
};

[返回本类函数列表] [返回页首] gleIsInitScene()：判断是否需要初始化场景

在第一次执行场景代码之前，或者按F1切换窗口和全屏显示模式时，都需要初始化场景，此时该函数返回1（逻辑真），否则返回0（逻辑假）。
一般在场景绘制代码的开始处使用该函数。

[例子]

[返回本类函数列表] [返回页首] gleGetWindowSize(x,y)：获得绘图窗口尺寸

x为窗口宽度，y为窗口高度。

[例子]

[返回本类函数列表] [返回页首] gleGetMouseMsg(Msg,x,y)：获得鼠标消息

Msg为鼠标消息。x,y为产出此鼠标消息的鼠标位置，以窗口左上角为坐标原点，x表示离原点的水平距离，y表示离原点的垂直距离。

[例子]

gleDrawScene(HFor("Scene")),stop();               //启动场景绘制，就退出

f(x)=x*sin[x];                                    //一元函数定义

Scene(:x,y,xx,yy,a)=
{
    glClear[],                                    //清除屏幕以及深度缓存
    glLoadIdentity[],                             //重置视图

    if[gleGetMouseMsg(WM_LBUTTONDOWN,&x,&y),a=1],
    if[gleGetMouseMsg(WM_LBUTTONUP,0,1),a=0],
    gleGetWindowSize[&xx,&yy],

    glTranslated[(x-xx/2)/100,(yy/2-y)/100,-10.0],//移动坐标
    glColor3d[1.0,x/xx,y/yy],                     //设置颜色

    if{a,lgPlot[@f,-x,y,LG_AXES,-3.0,3.0,-2.0,2.0]},//绘制一元函数图象

    glePrintCn["按鼠标左键"]
};

[返回本类函数列表] [返回页首] gleAxis(GetXYZ)或gleAxis(XYZ,SetXYZ)或gleAxis(SetX,SetY,SetZ)：设置或获得OpenGl屏幕坐标

    gleAxis(GetXYZ)：GetXYZ=1时获得屏幕X坐标，X坐标水平方向，向右为正。GetXYZ=2时获得屏幕Y坐标，Y坐标垂直方向，向上为正。GetXYZ=3时获得屏幕Z坐标，Z坐标前后方向，向前（屏幕外）为正。返回值为相应坐标的最新值。

    gleAxis(XYZ,SetXYZ)：XYZ=1时设置屏幕X坐标为SetXYZ。XYZ=2时设置屏幕Y坐标为SetXYZ。XYZ=3时设置屏幕Z坐标为SetXYZ。返回值为相应坐标的最新值。

    gleAxis(SetX,SetY,SetZ)：设置屏幕坐标X=SetX,Y=SetY,Z=SetZ。返回值为0。

[例子]

gleDrawScene(HFor("Draw")),stop();      //启动场景绘制，就退出

initScene()=                            //定义初始化函数
{
    gleAxis(-5.0,0.0,-15.0)             //设置窗口模式
};

Draw()=                                 //场景绘制函数
{
    if[gleIsInitScene(),initScene()],   //需要初始化场景时，就执行初始化函数

    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glColor3d[1.0,0.0,0.0],             //设置颜色
    glePrint["Hello OpenLuGl !"]        //绘制英文字符串
};

[返回本类函数列表] [返回页首] gleClear()：清除申请的空间

该函数删除以前申请但现在已无用的空间。

[例子]

[返回本类函数列表] [返回页首] gleSetWindowMode(GLE_ParentWindow,hParentWindow,GLE_WindowStyle,WindowStyle,... ...)：设置窗口模式

该函数用于设置OpenLuGl窗口模式。设置窗口模式后仅在切换窗口时起作用。该函数可一次设置多组参数，每组参数的第一个标识参数的类型，后面紧跟着参数值。参数标识及参数值的意义如下所示。

窗口类样式：

窗口扩展样式：

窗口样式：

该函数可能返回如下运行错误：1、不可识别关键字。2、参数不符合要求。

[例子]

[返回本类函数列表] [返回页首] gleSetWindowText("abc")：设置窗口标题

将绘图窗口的标题设为指定的字符串。

该函数可能返回如下运行错误：1、参数必须为字符串。

[例子]

gleDrawScene(HFor("Draw")),stop();      //启动场景绘制，就退出

initScene()=                            //定义初始化函数
{
    gleSetWindowText("abc")             //设置窗口标题
};

Draw()=                                 //场景绘制函数
{
    if[gleIsInitScene(),initScene()],   //需要初始化场景时，就执行初始化函数

    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glTranslated[-5.0,0.0,-15.0],       //移动坐标
    glColor3d[1.0,0.0,0.0],             //设置颜色
    glePrint["Hello OpenLuGl !"]        //绘制英文字符串
};

[返回本类函数列表] [返回页首] gleShowCursor(bool)：显示或隐藏光标

bool为逻辑真时显示光标，bool为逻辑假时隐藏光标。

[例子]

gleDrawScene(HFor("Draw")),stop();      //启动场景绘制，就退出

initScene()=                            //定义初始化函数
{
    gleShowCursor(false)                //隐藏光标
};

Draw()=                                 //场景绘制函数
{
    if[gleIsInitScene(),initScene()],   //需要初始化场景时，就执行初始化函数

    glClear[],                          //清除屏幕以及深度缓存
    glLoadIdentity[],                   //重置视图
    glTranslated[-5.0,0.0,-15.0],       //移动坐标
    glColor3d[1.0,0.0,0.0],             //设置颜色
    glePrint["Hello OpenLuGl !"]        //绘制英文字符串
};

[返回本类函数列表] [返回页首] gleOr(i1,i2,... ...)：按位或函数

求无符号整数i1,i2,... ...的按位或。

[例子]

    glClear[gleOr(GL_COLOR_BUFFER_BIT,GL_DEPTH_BUFFER_BIT)]  //清除屏幕以及深度缓存

[返回本类函数列表] [返回页首] gleMessageBox["消息框中显示的字符串","作为标题的字符串"]：消息框函数

格式1：gleMessageBox["消息框中显示的字符串","作为标题的字符串"]
格式2：gleMessageBox["消息框中显示的字符串","作为标题的字符串",nType]
格式3：gleMessageBox[HWND,"消息框中显示的字符串","作为标题的字符串",nType]

说明：HWND标识将被创建的消息框的拥有窗口，如果此参数为0，则消息框没有拥有窗口；nType指定一个决定对话框的内容和行为的位标志集，此参数可以为下列标志组中标志的组合：
    MB_OK
    MB_OKCANCEL
    MB_YESNO
    MB_YESNOCANCEL
其他标志请参考WINDOWS API手册中该函数的说明。
返回值：如果没有足够的内存来创建消息框，则返回值为0。如果函数调用成功，则返回值为下列对话框返回的菜单项目值中的一个：
    IDABORT：Abort按钮被选中。
    IDCANCEL：Cancel按钮被选中。
    IDIGNORE：Ignore按钮被选中。
    IDNO：NO按钮被选中。
    IDOK：OK按钮被选中。
    IDRETRY：RETRY按钮被选中。
    IDYES：YES按钮被选中。
标志和返回值的具体值请参考WINDOWS API手册，也可以自行验证。

该函数可能返回如下运行错误：1：参数设置不符合要求；2：指定的字符串不存在。

[返回本类函数列表] [返回页首] gleReSetPara("x1",&x1,"x2",&x2,... ...)：重置参数

该函数打开一个模态窗口对指定的参数进行重新设置。该函数的参数必须成对，每对参数中，第一个参数为字符串，对第二个参数进行说明；第二个参数为要修改的参数 （整数或实数），必须用引用方式传递。

该函数可能返回如下运行错误：1：没有参数或参数不成对；2：每对参数中，第一个参数必须为字符串；3：不可识别参数。

[例子]

[返回本类函数列表] [返回页首] gleFindWindow("ClassName","WindowName")或gleFindWindow(hwndParent,hwndChildAfter,"ClassName","WindowName")：获得一个（顶层）窗口的句柄

格式1：gleFindWindow("ClassName","WindowName")：获得一个顶层窗口的句柄
格式1：gleFindWindow(hwndParent,hwndChildAfter,"ClassName","WindowName")：获得一个窗口的句柄

说明：hwndParent为要查找子窗口的父窗口的句柄。hwndChildAfter为子窗口句柄，查找从在Z序中的下一个子窗口开始，子窗口必须为hwndParent的直接子窗口而非后代窗口。"ClassName"为窗口类名字符串。"WindowName"为窗口标题字符串。

该函数可能返回如下运行错误：1：参数不符合要求；2：窗口类名和窗口标题必须为字符串。

[例子]

initScene()=                             //定义初始化函数
{   gleSetWindowMode(                    //设置窗口模式。预先启动Explorer，不打开任何网页，使窗口标题如下，OpenLuGl窗口将成为Explorer的子窗口
        GLE_ParentWindow,gleFindWindow("IEFrame","about:blank - Microsoft Internet Explorer"),
        GLE_WindowPosition,50,200,
        GLE_WindowWidthAndHeight,500,300
        )
};

gleDrawScene(HFor("Draw")),initScene(),stop(); //启动场景绘制，就退出。注意initScene()的位置

Draw()=                                  //场景绘制函数
{
    if[gleIsInitScene(),initScene()],    //需要初始化场景时，就执行初始化函数

    gleMoveWindow[],                     //移动窗口

    glClear[],                           //清除屏幕以及深度缓存
    glLoadIdentity[],                    //重置视图
    glTranslated[-5.0,0.0,-15.0],        //移动坐标
    glColor3d[1.0,0.0,0.0],              //设置颜色
    glePrint["Hello OpenLuGl !"]         //绘制英文字符串
};

[返回本类函数列表] [返回页首] gleRegConstState()：检查常量注册情况

该函数检查OpenLuGl向Lu注册常量的情况，仅显示未注册的常量。

[返回本类函数列表] [返回页首] gleMoveWindow()、gleMoveWindow(x)、gleMoveWindow(Wx,Wy,Width,Height)或gleMoveWindow(Wx,Wy,Width,Height,x)：移动窗口，改变窗口的位置和尺寸

格式1：gleMoveWindow()：OpenLuGl窗口的实际位置坐标为窗口原来的位置坐标与父窗口位置坐标之和。
格式2：gleMoveWindow(x)：OpenLuGl窗口的实际位置坐标即窗口原来的位置坐标。
格式3：gleMoveWindow(Wx,Wy,Width,Height)：OpenLuGl窗口的实际位置坐标为指定的坐标值Wx,Wy与父窗口位置坐标之和。
格式4：gleMoveWindow(Wx,Wy,Width,Height,x)：OpenLuGl窗口的实际位置坐标即指定的坐标值Wx,Wy。

说明：Wx,Wy为新指定的窗口位置。Width,Height为新指定的窗口宽度和高度。x为任意值。OpenLuGl窗口的实际位置坐标指gleMoveWindow()函数内部调用API函数MoveWindow()时用的实际位置参数。

该函数可能返回如下运行错误：1：参数个数不符合要求。

[例子]

gleDrawScene(HFor("Draw")),stop(); //启动场景绘制，就退出

Draw(:static,xx,ii)=               //场景绘制函数
{
    if[xx>=500,ii=-0.1,xx=500],if[xx<=100,ii=0.1,xx=100],xx=xx+ii,
    gleMoveWindow[rtoi(xx),200,rtoi(xx),300],  //移动窗口

    glClear[],                     //清除屏幕以及深度缓存
    glLoadIdentity[],              //重置视图
    glTranslated[-5.0,0.0,-15.0],  //移动坐标
    glColor3d[1.0,0.0,0.0],        //设置颜色
    glePrint["Hello OpenLuGl !"]   //绘制英文字符串
};

[返回本类函数列表] [返回页首] gleSaveScene()：将OpenLuGl图像保存为文件

该函数将OpenLuGl图像保存为文件。仅支持BMP文件。

11 lg函数 ：实用绘图函数 [返回页首]

[返回本类函数列表] [返回页首] lgMesh(X1,X2,Y1,Y2,x1,x2,y1,y2)：绘制二维网格。

说明：绘制二维网格(X1,X2,Y1,Y2)，每个坐标轴10等分；(x1,x2,y1,y2)将标注在坐标轴上。

例子：

gleDrawScene[HFor("Scene")],stop();      //设置场景绘制函数后退出

Scene()=
{
    glClear[],                           //清除屏幕以及深度缓存
    glLoadIdentity[],                    //重置视图
    glTranslated[0.0,0.0,-30.0],         //移动坐标
    glColor3d[1.0,0.0,0.0],              //设置颜色
    lgMesh[-10.0,10.0,-10.0,10.0,-5.0,5.0,-8.0,8.0]//绘制三维网格
};

[返回本类函数列表] [返回页首] lgMesh3d(X1,X2,Y1,Y2,Z1,Z2,x1,x2,y1,y2,z1,z2)：绘制三维网格。

说明：绘制三维网格(X1,X2,Y1,Y2,Z1,Z2)，每个坐标轴10等分；(x1,x2,y1,y2,z1,z2)将标注在坐标轴上。

例子：

gleDrawScene[HFor("Scene")],stop();      //设置场景绘制函数后退出

Scene()=
{
    glClear[],                           //清除屏幕以及深度缓存
    glLoadIdentity[],                    //重置视图
    glTranslated[0.0,0.0,-30.0],         //移动坐标
    glColor3d[1.0,0.0,0.0],              //设置颜色
    lgMesh3d[-10.0,10.0,-10.0,10.0,0.0,-20.0,-2.0,2.0,-5.0,5.0,-8.0,8.0] //绘制三维网格
};

[返回本类函数列表] [返回页首] lgPlot[]：绘制一元函数图象

lgPlot[hF,-15.0,15.0,LG_Y,-20.0,20.0,LG_AXES,-5.0,5.0,-3.0,3.0,LG_PLOTPOINTS,500,LG_CUT,LG_NOAXES,LG_NODRAW];

说明：hF为已经定义的一元函数句柄；-15.0,15.0为自变量范围；LG_Y,-20.0,20.0为函数值范围，若缺省函数值范围，则自动生成自变量区间内的完整图象；LG_AXES,-5.0,5.0,-3.0,3.0设定屏幕坐标上的绘图区域，缺省的绘图区域是-5.0,5.0,-5.0,5.0；LG_PLOTPOINTS,500设定了自变量的分割数目，缺省的分割数目为1000；LG_CUT表示将切除绘图区域外的线段，缺省是将绘图区域外的线段绘制在绘图区域的边界上；LG_NOAXES表示不绘制坐标轴，缺省是绘制坐标轴；LG_NODRAW表示不绘制函数图象，只绘制坐标轴，缺省是既绘制图象又绘制坐标轴。LG_Y、LG_AXES、LG_PLOTPOINTS、LG_CUT、LG_NOAXES、LG_NODRAW是可选项。

该函数可能返回如下运行错误：

1、参数不匹配；
2、不可识别的描述符；
3、非法的表达式句柄；
4、指定的表达式不是一元函数；
5、不可识别参数；
6、一元函数返回值非法。

例子：

gleDrawScene[HFor("Scene")],stop();      //设置场景绘制函数后退出

f(x)=x*sin[x];                           //一元函数定义

Scene()=
{
    glClear[],                           //清除屏幕以及深度缓存
    glLoadIdentity[],                    //重置视图
    glTranslated[0.0,0.0,-10.0],         //移动坐标，向屏幕里移动10个单元
    glColor3d[1.0,0.0,0.0],              //设置颜色
    lgPlot[@f,-10.0,10.0,LG_AXES,-3.0,3.0,-2.0,2.0]  //绘制一元函数图象
};

[返回本类函数列表] [返回页首] lgParaPlot[]：绘制平面曲线的参数方程图象

lgParaPlot[hX,hY,-15.0,15.0,LG_XY,-15.0,15.0,-20.0,20.0,LG_AXES,-5.0,5.0,-3.0,3.0,LG_PLOTPOINTS,500,LG_CUT,LG_NOAXES,LG_NODRAW];

说明：hX,hY为已经定义的参数方程句柄；-15.0,15.0为自变量范围；LG_XY,-15.0,15.0,-20.0,20.0限定X和Y的变化范围，若缺省此项，则自动生成自变量区间内的完整图象；LG_AXES,-5.0,5.0,-3.0,3.0设定屏幕坐标上的绘图区域，缺省的绘图区域是-5.0,5.0,-5.0,5.0；LG_PLOTPOINTS,500设定了自变量的分割数目，缺省的分割数目为1000；LG_CUT表示将切除绘图区域外的线段，缺省是将绘图区域外的线段绘制在绘图区域的边界上；LG_NOAXES表示不绘制坐标轴，缺省是绘制坐标轴；LG_NODRAW表示不绘制函数图象，只绘制坐标轴，缺省是既绘制图象又绘制坐标轴。LG_XY、LG_AXES、LG_PLOTPOINTS、LG_CUT、LG_NOAXES、LG_NODRAW是可选项。

该函数可能返回如下运行错误：

1、参数不匹配；
2、不可识别的描述符；
3、非法的表达式句柄；
4、指定的表达式不是一元函数；
5、不可识别参数；
6、一元函数返回值非法。

例子：

gleDrawScene[HFor("Scene")],stop();      //设置场景绘制函数后退出

X(x)=sin[x]^3;                           //X参数定义
Y(x)=cos[x]^3;                           //Y参数定义
Scene()=
{
    glClear[],                           //清除屏幕以及深度缓存
    glLoadIdentity[],                    //重置视图
    glTranslated[0.0,0.0,-15.0],         //移动坐标，向屏幕里移动15个单元
    glColor3d[1.0,0.0,0.0],              //设置颜色
    lgParaPlot[@X,@Y,0.0,10.0]           //绘制绘制平面曲线的参数方程图象
};

[返回本类函数列表] [返回页首] lgPlot3d[]：绘制二元函数图象

lgPlot3d[hF,-5.0,5.0,-6.0,6.0,LG_Z,-2.0,2.0,LG_AXES,-3.0,5.0,-3.0,6.0,-6.0,0.0,LG_PLOTPOINTS,50,30,LG_CUT,LG_NOAXES,LG_NOMESH,LG_NODRAW];

说明：hF为已经定义的二元函数句柄；-5.0,5.0为x的变化范围，-6.0,6.0为y的变化范围；LG_Z,-2.0,2.0为z的变化范围，若缺省此项，则自动生成自变量区间内的完整图象；LG_AXES,-3.0,5.0,-3.0,6.0,-6.0,0.0设定屏幕坐标上的绘图区域，-3.0,5.0设定X轴的位置，-3.0,6.0设定Y轴的位置，-6.0,0.0设定Z轴的位置，缺省的绘图区域是-5.0,5.0,-5.0,5.0,-5.0,5.0；LG_PLOTPOINTS,50,30中的50和30设定了x和y的分割数目，缺省的分割数目分别是50和50；LG_CUT表示将切除绘图区域外的图象，缺省是将绘图区域外的图象绘制在绘图区域的边界上；LG_NOAXES表示不绘制坐标轴，缺省是绘制坐标轴；LG_NOMESH表示不绘制网格，缺省是绘制网格；LG_NODRAW表示不绘制函数图象，只绘制坐标轴，缺省是既绘制图象又绘制坐标轴。LG_Z、LG_AXES、LG_PLOTPOINTS、LG_CUT、LG_NOAXES、LG_NOMESH、LG_NODRAW是可选项。

该函数可能返回如下运行错误：

1、参数不匹配；
2、不可识别的描述符；
3、非法的表达式句柄；
4、指定的表达式不是二元函数；
5、不可识别参数；
6、二元函数返回值非法。

例子1：

gleDrawScene[HFor("Scene")],stop();      //设置场景绘制函数后退出

f(x,y)=(x^2-2*x)*exp(-x*x-y^2-x*y);

Scene(:static,rot)=
{
    glClear[],
    glLoadIdentity[],
    glTranslated[0.0,0.0,-20.0],
    glColor3d[0.0,1.0,0.0],              //设置颜色
    glRotated[1.0*rot++,1.0,1.0,1.0],    //使图象连续旋转
    lgPlot3d[@f,-3.0,3.0,-3.0,3.0]
};

例子2：

gleDrawScene[HFor("Scene")],stop();

//让图形随鼠标移动。factor为比例因子，factor越大则移动幅度越大。
luglFollowMouse(factor:x,y,xx,yy,xxx,yyy,static,luglFollowMouse,xMouse,yMouse)=
{
    if[gleGetMouseMsg(WM_LBUTTONDOWN,&x,&y),luglFollowMouse=1,xMouse=x,yMouse=y],
    gleGetWindowSize[&xxx,&yyy],
    if[luglFollowMouse,gleGetMouseMsg(WM_MOUSEMOVE,&xx,&yy),gleAngle[1,gleAngle(1)+(yy-yMouse)/yyy*factor],gleAngle[2,gleAngle(2)+(xx-xMouse)/xxx*factor]],
    if[gleGetMouseMsg(WM_LBUTTONUP,&xx,&yy),luglFollowMouse=0],
    glRotated[gleAngle(1),1.0,0.0,0.0], //使图象沿X轴旋转
    glRotated[gleAngle(2),0.0,1.0,0.0], //使图象沿Y轴旋转
    glRotated[gleAngle(3),0.0,0.0,1.0]  //使图象沿Z轴旋转
};

f(x,y:r)= r=sqrt[(x-50)^2+(y-50)^2]+exp[1.0], sin[r]/r+1;

Scene()=                  //场景绘制函数
{
    glClear[],
    glColor3d[1.0,0.0,0.0],//设置颜色
    gleAxesAngle[],       //显示坐标和旋转角度
    glLoadIdentity[],
    glTranslated[0.0,0.0,-20.0],
    glColor3d[0.0,1.0,0.0],//设置颜色
    luglFollowMouse[2],   //通过鼠标拖动变换任意角度来观察物体
    lgPlot3d[@f,0.0,100.0,0.0,100.0,LG_NOMESH] //绘制二元函数图形
};

[返回本类函数列表] [返回页首] lgParaPlot3d[]：绘制三维参数方程图象

lgParaPlot3d[hX,hY,hZ,-5.0,5.0,-6.0,6.0,LG_XYZ,-3.0,3.0,-5.0,5.0,-2.0,2.0,LG_AXES,-3.0,5.0,-3.0,6.0,-6.0,0.0,LG_PLOTPOINTS,50,30,LG_CUT,LG_NOAXES,LG_NOMESH,LG_NODRAW];

说明：hX,hY,hZ为已经定义的参数方程句柄；-5.0,5.0为x的变化范围，-6.0,6.0为y的变化范围；LG_XYZ,-3.0,3.0,-5.0,5.0,-2.0,2.0为限定的"X","Y","Z"的变化范围，若缺省此项，则自动生成自变量区间内的完整图象；LG_AXES,-3.0,5.0,-3.0,6.0,-6.0,0.0设定屏幕坐标上的绘图区域，-3.0,5.0设定X轴的位置，-3.0,6.0设定Y轴的位置，-6.0,0.0设定Z轴的位置，缺省的绘图区域是-5.0,5.0,-5.0,5.0,-5.0,5.0；LG_PLOTPOINTS,50,30中的50和30设定了x和y的分割数目，缺省的分割数目分别是50和50；LG_CUT表示将切除绘图区域外的图象，缺省是将绘图区域外的图象绘制在绘图区域的边界上；LG_NOAXES表示不绘制坐标轴，缺省是绘制坐标轴；LG_NOMESH表示不绘制网格，缺省是绘制网格；LG_NODRAW表示不绘制函数图象，只绘制坐标轴，缺省是既绘制图象又绘制坐标轴。LG_XYZ、LG_AXES、LG_PLOTPOINTS、LG_CUT、LG_NOAXES、LG_NOMESH、LG_NODRAW是可选项。

该函数可能返回如下运行错误：

1、参数不匹配；
2、不可识别的描述符；
3、非法的表达式句柄；
4、指定的表达式不是二元函数；
5、不可识别参数；
6、二元函数返回值非法。

例子：

gleDrawScene[HFor("Scene")],stop();      //设置场景绘制函数后退出

x(x,y)=[2-cos[x]]*cos[y];
y(x,y)=[2-cos[x]]*sin[y];
z(x,y)=sin[x];

Scene(:static,Rotate)=
{
    glClear[],
    glLoadIdentity[],
    glTranslated[0.0,0.0,-20.0],
    glColor3d[0.0,1.0,0.0],              //设置颜色
    glRotated[1.0*Rotate++,1.0,1.0,1.0], //使图象连续旋转
    lgParaPlot3d[@x,@y,@z,-3.0,3.0,-3.0,3.0]
};

版权所有© Lu程序设计 2002-2014，保留所有权利
E-mail: forcal@sina.com  QQ：630715621
最近更新: 2014年02月22日