C++；和过剩平稳运动 我是新的C++图形用户，我有以下代码

这是密码

#include <windows.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

#include <stdlib.h>
#include <math.h>

float angle = 0.0f;
float lx = 0.0f, lz = -1.0f;
float x = 0.0f, z = 5.0f;

float deltaAngle = 0.0f;
float deltaMove = 0;

void drawSnowMan(){

    glColor3f(1.0f, 1.0f, 1.0f);

    glTranslatef(0.0f, 0.75f, 0.0f);
    glutSolidSphere(0.75f, 20, 20);

    glTranslatef(0.0f, 1.0f, 0.0f);
    glutSolidSphere(0.25f, 20, 20);

    glPushMatrix();
    glColor3f(0.0f, 0.0f, 0.0f);
    glTranslatef(0.5f, 0.10f, 0.18f);
    glutSolidSphere(0.05f, 10, 10);
    glTranslatef(-0.1f, 0.0f, 0.0f);
    glutSolidSphere(0.05f, 10, 10);
    glPopMatrix();

    glColor3f(1.0f, 0.5f, 0.5f);
    glutSolidCone(0.8f, 0.5f, 10, 2);

}

void changeSize(int w, int h){

    if(h == 0)
        h = 1;
    float ratio = 1.0*w/h;

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glViewport(0,0,w,h);

    gluPerspective(45.0f, ratio, 0.1f, 100.0f);

    glMatrixMode(GL_MODELVIEW);

}

void computePos(float deltaMove){
    x += deltaMove * lx * 0.1f;
    z += deltaMove * lz * 0.1f;
}

void computeDir(float deltaAngle){
    angle += deltaAngle;
    lx = sin(angle/75.0);
    lz = -cos(angle/75.0);
}

void pressKey(int key, int xx, int yy){
    switch(key){
    case GLUT_KEY_LEFT: deltaAngle = -0.5f; break;
    case GLUT_KEY_RIGHT: deltaAngle = 0.5; break;
    case GLUT_KEY_UP: deltaMove = 0.5f; break;
    case GLUT_KEY_DOWN: deltaMove = -0.5f; break;
    }
}

void relaseKey(int key, int x, int y){
    switch(key){
    case GLUT_KEY_LEFT:
    case GLUT_KEY_RIGHT: deltaAngle = 0.0f; break;
    case GLUT_KEY_UP:
    case GLUT_KEY_DOWN: deltaMove = 0; break;
    }
}

void renderScene(void){

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();

    if(deltaMove)
        computePos(deltaMove);
    if(deltaAngle)
        computeDir(deltaAngle);

    gluLookAt(  x, 1.0f, z,
                x+lx, 1.0f, z+lz,
                0.0f, 1.0f, 0.0f
              );

    glColor3f(0.9f, 0.9f, 0.9f);

    glBegin(GL_QUADS);
        glVertex3f(-100.0f, 0.0f, -100.0f);
        glVertex3f(-100.0f, 0.0f, 100.0f);
        glVertex3f(100.0f, 0.0f, 100.0f);
        glVertex3f(100.0f, 0.0f, -100.0f);
    glEnd();

    angle += 0.1f;

    for(int i = -3; i < 3; i++){
        for(int j = -3; j < 3; j++){
            glPushMatrix();
            glTranslatef(i*10.0,0, j*10.0);
            drawSnowMan();
            glPopMatrix();
        }
    }
    glutSwapBuffers();
}

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitWindowSize(320,320);
    glutInitWindowPosition(100,100);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

    glutCreateWindow("Lighthouse 3D");

    glutDisplayFunc(renderScene);
    glutReshapeFunc(changeSize);

    glutIdleFunc(renderScene);

    glutSpecialFunc(pressKey);
    glutIgnoreKeyRepeat(1);
    glutSpecialUpFunc(relaseKey);

    glEnable(GL_DEPTH_TEST);

    glutMainLoop();

    return 1;
}

#包括
#苹果__
#包括
#否则
#包括
#恩迪夫
#包括
#包括
浮动角度=0.0f；
浮点数lx=0.0f，lz=-1.0f；
浮动x=0.0f，z=5.0f；
浮动三角洲角=0.0f；
浮动增量=0；
雪人{
GL3F（1.0f，1.0f，1.0f）；
glTranslatef（0.0f，0.75f，0.0f）；
固体球（0.75f，20，20）；
glTranslatef（0.0f，1.0f，0.0f）；
固体球（0.25f，20，20）；
glPushMatrix（）；
GL3F（0.0f，0.0f，0.0f）；
glTranslatef（0.5f，0.10f，0.18f）；
固体球（0.05f，10，10）；
GLTRANSTEF（-0.1f、0.0f、0.0f）；
固体球（0.05f，10，10）；
glPopMatrix（）；
GL3F（1.0f，0.5f，0.5f）；
固体锥（0.8f、0.5f、10、2）；
}
无效更改大小（整数w、整数h）{
如果（h==0）
h=1；
浮球比=1.0*w/h；
glMatrixMode（GL_投影）；
glLoadIdentity（）；
glViewport（0,0，w，h）；
（45.0f，比率，0.1f，100.0f）；
glMatrixMode（GLU模型视图）；
}
无效计算（浮动增量移动）{
x+=deltaMove*lx*0.1f；
z+=deltaMove*lz*0.1f；
}
void computeDir（浮动三角洲角）{
角度+=三角洲角度；
lx=sin（角度/75.0）；
lz=-cos（角度/75.0）；
}
无效按键（int键，int xx，int yy）{
开关（钥匙）{
案例GLUT_键_左：deltaAngle=-0.5f；中断；
案例GLUT\U KEY\U RIGHT:deltaAngle=0.5；中断；
案例过量：deltaMove=0.5f；中断；
案例过量键关闭：deltaMove=-0.5f；中断；
}
}
无效relaseKey（整数键、整数x、整数y）{
开关（钥匙）{
案例过剩\u键\u左：
案例过量键右：三角角=0.0f；中断；
案例过多关键点：
案例过量键向下：deltaMove=0；中断；
}
}
void renderScene（void）{
glClear（GL_颜色_缓冲_位| GL_深度_缓冲_位）；
glLoadIdentity（）；
if（德尔塔莫夫）
computePos（德尔塔莫夫）；
if（三角洲角）
计算IR（三角洲角）；
gluLookAt（x，1.0f，z，
x+lx，1.0f，z+lz，
0.0f，1.0f，0.0f
);
GL3F（0.9f，0.9f，0.9f）；
glBegin（GL_QUADS）；
glVertex3f（-100.0f，0.0f，-100.0f）；
glVertex3f（-100.0f，0.0f，100.0f）；
glVertex3f（100.0f、0.0f、100.0f）；
glVertex3f（100.0f，0.0f，-100.0f）；
格伦德（）；
角度+=0.1f；
for（int i=-3；i<3；i++）{
对于（int j=-3；j<3；j++）{
glPushMatrix（）；
glTranslatef（i*10.0,0，j*10.0）；
雪人（）；
glPopMatrix（）；
}
}
glutSwapBuffers（）；
}
int main（int argc，char*argv[]）
{
glutInit（&argc，argv）；
glutInitWindowSize（320320）；
位置（100100）；
glutInitDisplayMode（GLUT_RGB | GLUT_DOUBLE | GLUT_深度）；
玻璃窗（“灯塔3D”）；
glutDisplayFunc（渲染场景）；
GLUTEFUNC（更改大小）；
glutIdleFunc（渲染场景）；
glutSpecialFunc（按键）；
GLUTIGNOREKEYREPLATE（1）；
glutSpecialUpFunc（relaseKey）；
glEnable（GLU深度试验）；
glutMainLoop（）；
返回1；
}

---

我的问题是，当我试着向左转弯时，我一直按着左键，一切都很好。当我尝试左击一次时，动作一点也不平稳。在某些情况下，如果按钮行程过快，它甚至会转向相反的方向

我想你指的是键盘而不是鼠标，在这种情况下，要有“更平滑”和“更慢”的感觉，你需要调整

三角洲

值，这可能太高了

这只是一个临时修复，因为这些值可能以不同的方式影响其他机器-一些可能更快，一些可能更慢。您需要计算渲染循环中主机的FPS，并将

delta

值与之相乘，以便在每台计算机上都具有相同的性能。这被称为基于时间的运动，是每个现代图形应用程序的基本特征

当一个点在屏幕上移动过快时，这正是下面教程中发生的情况

• 一个

  glutIdleFunc（）

  会消耗掉你所有的电池/CPU/GPU，用一个

  GLUTIMERFUNC（）

  来按照一个可预测的、合理的时间表重新绘制
• 在帧之间累积输入状态，并将其应用于

  glutTimerFunc（）

  ，而不是尝试在keypup/keypdown回调中正确地执行
• 无需使用glutResizeFunc（），只需在绘图前完成所有操作
<> LI>你使用C++，所以你应该使用C++标题的C++版本，比如<代码> <代码>，而不是<代码> <代码> .<

总而言之：

#include <GL/glut.h>
#include <cmath>
#include <map>

std::map< int, bool > keys;
void pressKey(int key, int xx, int yy)
{
    keys[ key ] = true;
}
void relaseKey(int key, int x, int y)
{
    keys[ key ] = false;
}

float angle = 0.0f;
float lx = 0.0f, lz = -1.0f;
float x = 0.0f, z = 5.0f;
void update()
{
    const float angleStep = 0.5f;
    if( keys[ GLUT_KEY_LEFT  ] )    angle -= angleStep;
    if( keys[ GLUT_KEY_RIGHT ] )    angle += angleStep;

    const float moveStep = 0.5f;
    float move = 0.0f;
    if( keys[ GLUT_KEY_DOWN  ] )    move -= moveStep;
    if( keys[ GLUT_KEY_UP    ] )    move += moveStep;

    x += move * lx * 0.1f;
    z += move * lz * 0.1f;

    lx = sin(angle/75.0);
    lz = -cos(angle/75.0);
}

void drawSnowMan()
{
    glColor3f(1.0f, 1.0f, 1.0f);

    glTranslatef(0.0f, 0.75f, 0.0f);
    glutSolidSphere(0.75f, 20, 20);

    glTranslatef(0.0f, 1.0f, 0.0f);
    glutSolidSphere(0.25f, 20, 20);

    glPushMatrix();
    glColor3f(0.0f, 0.0f, 0.0f);
    glTranslatef(0.5f, 0.10f, 0.18f);
    glutSolidSphere(0.05f, 10, 10);
    glTranslatef(-0.1f, 0.0f, 0.0f);
    glutSolidSphere(0.05f, 10, 10);
    glPopMatrix();

    glColor3f(1.0f, 0.5f, 0.5f);
    glutSolidCone(0.8f, 0.5f, 10, 2);
}

void renderScene(void)
{
    glEnable(GL_DEPTH_TEST);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    const double w = glutGet( GLUT_WINDOW_WIDTH );
    const double h = glutGet( GLUT_WINDOW_HEIGHT );
    gluPerspective(45.0f, w / h, 0.1f, 100.0f);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    gluLookAt
        (
        x, 1.0f, z,
        x+lx, 1.0f, z+lz,
        0.0f, 1.0f, 0.0f
        );

    glColor3f(0.9f, 0.9f, 0.9f);

    glBegin(GL_QUADS);
    glVertex3f(-100.0f, 0.0f, -100.0f);
    glVertex3f(-100.0f, 0.0f, 100.0f);
    glVertex3f(100.0f, 0.0f, 100.0f);
    glVertex3f(100.0f, 0.0f, -100.0f);
    glEnd();

    for(int i = -3; i < 3; i++)
    {
        for(int j = -3; j < 3; j++)
        {
            glPushMatrix();
            glTranslatef(i*10.0,0, j*10.0);
            drawSnowMan();
            glPopMatrix();
        }
    }

    glutSwapBuffers();
}

void timer( int value )
{
    update();
    glutTimerFunc( 16, timer, 0 );
    glutPostRedisplay();
}

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitWindowSize(320,320);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

    glutCreateWindow("Lighthouse 3D");

    glutDisplayFunc(renderScene);
    glutSpecialFunc(pressKey);
    glutSpecialUpFunc(relaseKey);
    glutTimerFunc( 0, timer, 0 );

    glutMainLoop();

    return 1;
}

#包括
#包括
#包括
标准：：映射键；
无效按键（int键，int xx，int yy）
{
keys[key]=true；
}
无效relaseKey（整数键、整数x、整数y）
{
keys[key]=false；
}
浮动角度=0.0f；
浮点数lx=0.0f，lz=-1.0f；
浮动x=0.0f，z=5.0f；
无效更新（）
{
常数浮动角度步长=0.5f；
如果（键[GLUT_键左]）角度-=角度步长；
如果（键[GLUT\U键\U右]）角度+=角度步长；
常数浮点移动步长=0.5f；
浮动移动=0.0f；
如果（键[GLUT\U KEY\U DOWN]）移动-=moveStep；
如果（键[GLUT\U KEY\U UP]）移动+=moveStep；
x+=移动*lx*0.1f；
z+=移动*lz*0.1f；
lx=sin（角度/75.0）；
lz=-cos（角度/75.0）；
}
雪人
{
GL3F（1.0f，1.0f，1.0f）；
glTranslatef（0.0f，0.75f，0.0f）；
固体球（0.75f，20，20）；
glTranslatef（0.0f，1.0f，0.0f）；
固体球（0.25f，20，20）；
glPushMatrix（）；
GL3F（0.0f，0.0f，0.0f）；
glTranslatef（0.5f，0.10f，0.18f）；
固体球（0.05f，10，10）；
GLTRANSTEF（-0.1f、0.0f、0.0f）；
固体球（0.05f，10，10）；
glPopMatrix（）；
GL3F（1.0f，0.5f，0.5f）；
固体锥（0.8f、0.5f、10、2）；
}
void renderScene（void）
{
glEnable（GLU深度试验）；
glClear（GL_颜色_缓冲位| GL_深度