C++ 赢得积分'；OpenGl中的键盘输入法_C++_Opengl_Graphics_Glut

C++ 赢得积分'；OpenGl中的键盘输入法

c++ opengl graphics

C++ 赢得积分'；OpenGl中的键盘输入法,c++,opengl,graphics,glut,C++,Opengl,Graphics,Glut,我试图在OpenGl中从上到下移动几个点（水平渲染）。代码运行时没有任何错误。当我尝试处理->开始移动、加速/减速或停止移动等事件时，它不起作用。下面是代码 #include <gl/glut.h> int pointStatus=0; float pointX = 0.0f; float pointY = 0.0f; float speed, b = 0.5; char s; void Point(int x1, int y1) { glColor3f(1.0, 1.0, 1.0)

我试图在OpenGl中从上到下移动几个点（水平渲染）。代码运行时没有任何错误。当我尝试处理->开始移动、加速/减速或停止移动等事件时，它不起作用。下面是代码

#include <gl/glut.h>
int pointStatus=0;
float pointX = 0.0f;
float pointY = 0.0f;
float speed, b = 0.5;
char s;
void Point(int x1, int y1)
{
glColor3f(1.0, 1.0, 1.0); 
glPointSize(5);
glPushMatrix();

glBegin(GL_POINTS);
glVertex2i(x1, y1);
glPopMatrix();

glEnd();
}

void Draw()
{
int x=0, y=6;
for (x = 0; x <= 6; x +=  1)
    {
        Point(x,y); 
    }
glFlush();
}

void movePoint(int s, int x, int b)//
{
if (pointStatus == 1)
{
    pointY -= b + speed;
}
if (pointY>14)
{
    pointY = -6;
}
glPushMatrix();
glTranslatef(pointX, pointY, 0);
Draw();
glPopMatrix();
}

void handleKeypress(unsigned char key, int x, int y) 
{
if (key == '1')
{                      
    pointStatus = 1; // start
    b = +0.05;
    speed = 0.5;

}

else if (key == '=' || key == '+')
{
    pointStatus = 1;    //speed up
    b = +.05;
    speed += .2;

}
else if (key == '-' || key == '_')      
{
    pointStatus = 1; //speed down 
    b = -.05;
    speed -= .2;
}
else if (key == '2')
{
    pointStatus = 0; //stop
    speed = 0;
}
}

void myDisplay(void)
{
movePoint(s, b, speed);
//glFlush();
glutPostRedisplay();
glutSwapBuffers();
}

void Initialize() {
glClearColor(0.435294, 0.258824, 0.258824,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-14.0, 14.0, -14.0, 14.0, -1.0, 10.0); // left, right, bottom, top, near and far
}

int main(int iArgc, char** cppArgv) {
glutInit(&iArgc, cppArgv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(700,500);
glutInitWindowPosition(400, 200);
glutCreateWindow("tuntaa");
Initialize();

glutDisplayFunc(myDisplay);
glutKeyboardFunc(handleKeypress);
glutMainLoop();
return 0;
}

#包括
int pointStatus=0；
浮点数X=0.0f；
浮点Y=0.0f；
浮动速度，b=0.5；
字符s；
空位点（整数x1，整数y1）
{
GL3F（1.0,1.0,1.0）；
gl点大小（5）；
glPushMatrix（）；
glBegin（总分）；
glVertex2i（x1，y1）；
glPopMatrix（）；
格伦德（）；
}
作废提款（）
{
int x=0，y=6；
对于（x=0；x 14）
{
尖头=-6；
}
glPushMatrix（）；
glTranslatef（pointX，pointY，0）；
Draw（）；
glPopMatrix（）；
}
void handleKeypress（无符号字符键，整数x，整数y）
{
如果（键=='1'）
{                      
pointStatus=1；//开始
b=+0.05；
速度=0.5；
}
else如果（键=='='.|键=='+'））
{
pointStatus=1；//加速
b=+.05；
速度+=.2；
}
else如果（键=='-'| |键=='|'）
{
pointStatus=1；//减速
b=-0.05；
速度-=.2；
}
否则如果（键=='2'）
{
pointStatus=0；//停止
速度=0；
}
}
void myDisplay（void）
{
移动点（s、b、速度）；
//glFlush（）；
再发现（）；
glutSwapBuffers（）；
}
void Initialize（）{
glClearColor（0.435294,0.258824,0.258824,0.0）；
glMatrixMode（GL_投影）；
glLoadIdentity（）；
格洛托（-14.0,14.0，-14.0,14.0，-1.0,10.0）；//左、右、下、上、近、远
}
int main（int iArgc，字符**cppArgv）{
glutInit（iArgc和cppArgv）；
glutInitDisplayMode（GLUT_SINGLE | GLUT_RGB）；
glutInitWindowSize（700500）；
位置（400200）；
GLUTACEATEWINDOW（“tuntaa”）；
初始化（）；
glutDisplayFunc（myDisplay）；
glutKeyboardFunc（手动按键）；
glutMainLoop（）；
返回0；
}

如果希望通过
```
glutIdleFunc（）
```
设置空闲回调，请不要从显示回调调用
```
glutPostRedisplay（）
```
不要从draw函数中更新状态，而是在单独的过程中进行更新
您缺少一个
```
glClear（）
```
重置投影并在每一帧上进行modelvew，有助于防止难以诊断的错误
如果要使用
```
glutSwapBuffers（）
```
，请使用
```
glutdouble
```
如果需要偶数帧速率（在缺少可靠的vsync的情况下），请设置计时器回调并调用
```
glutPostRedisplay（）
```
（并重新配置计时器）。你也可以在那里做物理更新
奖励积分：
```
glutGet（GLUT运行时间）
```
&

总而言之：

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

std::map< int, bool > keys;
void special( int key, int x, int y )
{
    keys[ key ] = true;
}
void specialUp( int key, int x, int y )
{
    keys[ key ] = false;
}

float xpos = 0;
float ypos = 0;
void update()
{
    const float speed = 1.0;
    if( keys[ GLUT_KEY_LEFT ] )
    {
        xpos -= speed;
    }
    if( keys[ GLUT_KEY_RIGHT ] )
    {
        xpos += speed;
    }
    if( keys[ GLUT_KEY_UP ] )
    {
        ypos += speed;
    }
    if( keys[ GLUT_KEY_DOWN ] )
    {
        ypos -= speed;
    }
}

void display()
{
    glClearColor( 0.435294, 0.258824, 0.258824, 0.0 );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    glOrtho( -100, 100, -100, 100, -1, 1 );

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();

    glTranslatef( xpos, ypos, 0 );
    glScalef( 10, 10, 1 );
    glBegin( GL_QUADS );
    glVertex2i( -1, -1 );
    glVertex2i(  1, -1 );
    glVertex2i(  1,  1 );
    glVertex2i( -1,  1 );
    glEnd();

    glutSwapBuffers();
}

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

int main( int argc, char **argv )
{
    glutInit( &argc, argv );
    glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE );
    glutInitWindowSize( 640, 640 );
    glutCreateWindow( "GLUT" );
    glutDisplayFunc( display );

    glutSpecialFunc( special );
    glutSpecialUpFunc( specialUp );

    glutTimerFunc( 0, timer, 0 );
    glutMainLoop();
    return 0;
}

#包括
#包括
标准：：映射键；
无效特殊（整数键、整数x、整数y）
{
keys[key]=true；
}
void specialUp（整数键、整数x、整数y）
{
keys[key]=false；
}
浮点xpos=0；
浮动ypos=0；
无效更新（）
{
常数浮动速度=1.0；
if（键[GLUT\U键\U左]）
{
xpos-=速度；
}
如果（键[GLUT\U KEY\U RIGHT]）
{
xpos+=速度；
}
if（键[GLUT\U KEY\U UP]）
{
ypos+=速度；
}
if（键[GLUT\U KEY\U DOWN]）
{
ypos-=速度；
}
}
无效显示（）
{
glClearColor（0.435294,0.258824,0.258824,0.0）；
glClear（GL_颜色_缓冲_位| GL_深度_缓冲_位）；
glMatrixMode（GL_投影）；
glLoadIdentity（）；
格洛托（-100100，-100100，-1,1）；
glMatrixMode（GLU模型视图）；
glLoadIdentity（）；
glTranslatef（xpos，ypos，0）；
glScalef（10,10,1）；
glBegin（GL_QUADS）；
glVertex2i（-1，-1）；
glVertex2i（1，-1）；
glVertex2i（1,1）；
glVertex2i（-1,1）；
格伦德（）；
glutSwapBuffers（）；
}
无效计时器（int值）
{
更新（）；
glutTimerFunc（16，定时器，0）；
再发现（）；
}
int main（int argc，字符**argv）
{
glutInit（&argc，argv）；
glutInitDisplayMode（GLUT_RGBA | GLUT_DOUBLE）；
GLUTINITWindowsSize（640640）；
GLUT（GLUT）；
glutDisplayFunc（显示器）；
glutSpecialFunc（特殊）；
glutSpecialUpFunc（specialUp）；
glutTimerFunc（0，定时器，0）；
glutMainLoop（）；
返回0；
}

如果希望通过
```
glutIdleFunc（）
```
设置空闲回调，请不要从显示回调调用
```
glutPostRedisplay（）
```
不要从draw函数中更新状态，而是在单独的过程中进行更新
您缺少一个
```
glClear（）
```
重置投影并在每一帧上进行modelvew，有助于防止难以诊断的错误
如果要使用
```
glutSwapBuffers（）
```
，请使用
```
glutdouble
```
如果需要偶数帧速率（在缺少可靠的vsync的情况下），请设置计时器回调并调用
```
glutPostRedisplay（）
```
（并重新配置计时器）。你也可以在那里做物理更新
奖励积分：
```
glutGet（GLUT运行时间）
```
&

总而言之：

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

std::map< int, bool > keys;
void special( int key, int x, int y )
{
    keys[ key ] = true;
}
void specialUp( int key, int x, int y )
{
    keys[ key ] = false;
}

float xpos = 0;
float ypos = 0;
void update()
{
    const float speed = 1.0;
    if( keys[ GLUT_KEY_LEFT ] )
    {
        xpos -= speed;
    }
    if( keys[ GLUT_KEY_RIGHT ] )
    {
        xpos += speed;
    }
    if( keys[ GLUT_KEY_UP ] )
    {
        ypos += speed;
    }
    if( keys[ GLUT_KEY_DOWN ] )
    {
        ypos -= speed;
    }
}

void display()
{
    glClearColor( 0.435294, 0.258824, 0.258824, 0.0 );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    glOrtho( -100, 100, -100, 100, -1, 1 );

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();

    glTranslatef( xpos, ypos, 0 );
    glScalef( 10, 10, 1 );
    glBegin( GL_QUADS );
    glVertex2i( -1, -1 );
    glVertex2i(  1, -1 );
    glVertex2i(  1,  1 );
    glVertex2i( -1,  1 );
    glEnd();

    glutSwapBuffers();
}

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

int main( int argc, char **argv )
{
    glutInit( &argc, argv );
    glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE );
    glutInitWindowSize( 640, 640 );
    glutCreateWindow( "GLUT" );
    glutDisplayFunc( display );

    glutSpecialFunc( special );
    glutSpecialUpFunc( specialUp );

    glutTimerFunc( 0, timer, 0 );
    glutMainLoop();
    return 0;
}

#包括
#包括
标准：：映射键；
无效特殊（整数键、整数x、整数y）
{
keys[key]=true；
}
void specialUp（整数键、整数x、整数y）
{
keys[key]=false；
}
浮点xpos=0；
浮动ypos=0；
无效更新（）
{
常数浮动速度=1.0；
if（键[GLUT\U键\U左]）
{
xpos-=速度；
}
如果（键[GLUT\U KEY\U RIGHT]）
{
xpos+=速度；
}
if（键[GLUT\U KEY\U UP]）
{
ypos+=速度；
}
if（键[GLUT\U KEY\U DOWN]）
{
ypos-=速度；
}
}
无效显示（）
{
glClearColor（0.435294,0.258824,0.258824,0.0）；
glClear（GL_颜色_缓冲_位| GL_深度_缓冲_位）；
glMatrixMode（GL_投影）；
glLoadIdentity（）；
格洛托（-100100，-100100，-1,1）；
glMatrixMode（GLU模型视图）；
glLoadIdentity（）；
glTranslatef（xpos，ypos，0）；
glScalef（10,10,1）；
glBegin（GL_QUADS）；
glVertex2i（-1，-1）；
glVertex2i（1，-1）；
glVertex2i（1,1）；
glVertex2i（-1,1）；
格伦德（）；
glutSwapBuffers（）；
}
无效计时器（int值）
{
更新（）；
glutTimerFunc（16，定时器，0）；
再发现（）；
}
int main(