c++ - 打砖 block 帮助。圆圈、划桨和笨拙的弹跳-6ren

c++ - 打砖 block 帮助。圆圈、划桨和笨拙的弹跳

转载作者：行者123 更新时间：2023-11-30 02:08:28

我用 OpenGL 编写了一个简单的打砖 block 游戏。球是使用以下方法绘制的二维圆:

for (float angle = 0; angle < (10); angle+=0.01)
 {
     glVertex2f((x_pos + sin(angle) * RADIUS), (y_pos + (cos(angle)) * RADIUS));
 }

当游戏改为全屏时，这会导致失真。半径定义为 0.025 。我也需要帮助来使桨运动平稳。另外，如果你玩过几次这个游戏，你会注意到在最左边，当球碰到 Racket 时，它会上升到一定高度然后弹回。完整代码:

#include <GL/openglut.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <cmath>
#define RADIUS 0.025
#define SPEED  0.001
int WIDTH = 900;
int HEIGHT =  650;
int RATIO = WIDTH/HEIGHT;
bool show[5][10];
float x_brick[4][9];
float y_brick[4][9];
float P_XPOS = 0;
float P_YPOS = -0.8;
bool phit_center = false , phit_corner = false;
bool game_over = false;
bool RIGHT = 1,LEFT = 0,UP = 1,DOWN = 0;
bool started = false;
float x_pos = 0,y_pos = -0.75;
bool hit = false;
int lives  = 3;
using namespace std;
void b_draw()
{
      glColor3f(1.0,0.0,0.0);
      glBegin(GL_QUADS);
      for(int a = 0; a < 9; a++)
      {
              for(int b = 0; b < 4; b++)
              {
                      if(show[b][a] == 1)
                      {
                                    glVertex2f(x_brick[b][a],y_brick[b][a]);
                                    glVertex2f(x_brick[b][a],y_brick[b][a] - 0.10); 
                                    glVertex2f(x_brick[b][a]+0.2,y_brick[b][a] - 0.10);
                                    glVertex2f(x_brick[b][a]+0.2,y_brick[b][a]);  
                      }
              }
      }
      glEnd();
}
void c_draw()
{
     glColor3f(0.0,0.0,0.0);
     glBegin(GL_TRIANGLE_FAN);
     glVertex2f(x_pos,y_pos);
     for (float angle = 0; angle < (10); angle+=0.01)
     {
         glVertex2f((x_pos + sin(angle) * RADIUS), (y_pos + (cos(angle)) * RADIUS));
     }
     glEnd();
}
bool b_hit()
{
     hit = false;
     int flag = 1;
     for(int a = 0; a < 10; a++)
     {
             for(int b =0; b < 4; b++)
             {
                     if(x_pos >= x_brick[b][a] && x_pos <= x_brick[b][a] + 0.2)
                     {
                              if(y_pos <= y_brick[b][a] && y_pos >= y_brick[b][a] - 0.1)
                              {
                                       if(show[b][a] == 1)
                                       {
                                                     show[b][a] = 0;
                                                     flag = 0;
                                                     hit = true;
                                                     break;
                                       }
                              }
                     }
             }
             if(flag == 0)
                     break;
     }
     return hit;
}
bool crashed()
{
     if(y_pos < P_YPOS - 0.05)
              return true;
     else return false;;
}
void p_hit()
{
     phit_corner = false;
     phit_center = false;
     if(x_pos <= P_XPOS + 0.13 && x_pos >= P_XPOS - 0.13)
     {
              if(y_pos <= P_YPOS)
              {
                       phit_center = true;
              }
     }
     else if((x_pos >= P_XPOS + 0.13 && x_pos <= P_XPOS + 0.2) || (x_pos <= P_XPOS - 0.13 && x_pos >= P_XPOS - 0.2))
     {
               if(y_pos <= P_YPOS)
               {
                        phit_corner = true;
               }
     }
}
 void c_move()
 {
      if(UP && RIGHT)
      {
           x_pos += (SPEED);
           y_pos += (SPEED);       
      }
      if(UP && LEFT)
      {
            x_pos -= (SPEED);
            y_pos += (SPEED);
      }
      if(DOWN && RIGHT)
      {
              x_pos += (SPEED);
              y_pos -= (SPEED);
      }
      if(DOWN && LEFT)
      {
              x_pos -= (SPEED);
              y_pos -= (SPEED);
      }
      b_hit();
      if(x_pos >= (RATIO-RADIUS))
      {
               RIGHT = 0;
               LEFT = 1;
      }
      else if(x_pos <= (-RATIO+RADIUS))
      {
           RIGHT = 1;
           LEFT = 0;
      }
      if(y_pos >= (RATIO-RADIUS) || hit )
      {
                  UP = 0;
                  DOWN = 1;
      }
      else if(y_pos <= (-RATIO+RADIUS) || hit )
      {
           UP = 1;
           DOWN = 0;
      }
      p_hit();
      if(phit_center)
      {
                     DOWN = 0;
                     UP = 1;
      }
      if(phit_corner)
      {
                     if(LEFT)
                     {
                             LEFT = 0;
                             RIGHT = 1;
                     }
                     else
                     {
                         RIGHT = 0;
                         LEFT = 1;
                     }
                     UP = 1;
                     DOWN = 0;
      }
}
void p_draw()
{
     glColor3f(0.0,0.0,0.0);
     glBegin(GL_QUADS);
                      glVertex2f(P_XPOS-0.2,P_YPOS);
                      glVertex2f(P_XPOS+0.2,P_YPOS);
                      glVertex2f(P_XPOS+0.2,P_YPOS-0.05);
                      glVertex2f(P_XPOS-0.2,P_YPOS-0.05);
     glEnd();
}

void BallLoop()
{
     glClearColor(1.0,1.0,1.0,0);
     glDisable(GL_DEPTH_TEST);
     glClear(GL_COLOR_BUFFER_BIT);
     glMatrixMode (GL_MODELVIEW);
     glLoadIdentity();
     c_draw();
     b_draw();
     p_draw();
     glFlush();
     if(started)
                c_move();
     if(crashed())
     {           
                 x_pos = 0;
                 y_pos = -0.7;
                 started = 0;
                 UP = 1;
                 RIGHT = 1;
                 DOWN = 0;
                 LEFT = 0;
     }

     glutSwapBuffers();
     glutPostRedisplay();
}
void user_input(unsigned char key, int x, int y)
{
     if(key == 13)
     started = true;
}
void ArrowKeys(int key, int x, int y)
{
     if(key==GLUT_KEY_LEFT && P_XPOS >= -0.8)
      for(float a = 0; a < 0.05; a+= 0.001)
      {
                                      P_XPOS -=0.003;
                                      BallLoop();
      }
     if(key==GLUT_KEY_RIGHT && P_XPOS <= 0.8)
     {
                            for(float a = 0; a < 0.05; a+= 0.001)
                            {
                                      P_XPOS +=0.003;
                                      BallLoop();
                            }
     }
}
void set_xy()
{
    for(int a = 0; a < 5; a++)
    {
            for(int b = 0; b < 10; b++)
            {
                    show[a][b] = 1;
            }
    }
    int c = 0;
    for(float a = -0.94; c <= 8; a+=0.21)
    {         

              for(int b = 0; b <= 5; b++)
              {
                      x_brick[b][c] = a;

              }
              c++;
    }
    int d = 0;
    for(float s = 0.99; d <= 3; s-=0.11)
    {
              for(int  r = 0; r < 9; r++)
              {
                       y_brick[d][r] = s;
              }
              d++;
    }
}
void changeSize(int w, int h) 
{

    if(h == 0)
        h = 1;
    RATIO = w/h;
    float ratio = 1.0* w / h;
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glViewport(0, 0, w, h);
    glMatrixMode(GL_MODELVIEW);
    BallLoop();
}
int main(int argc, char **argv)
{
    set_xy();
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
    glutInitWindowPosition(0,0);
    glutInitWindowSize(WIDTH,HEIGHT);                    
    glutCreateWindow("Brick Breaker - By Viraj");
    glutReshapeFunc(changeSize);
    glutDisplayFunc(BallLoop);
    glutKeyboardFunc(user_input);
    glutSpecialFunc(ArrowKeys);
    glutMainLoop(); 
    return 0;
}

最佳答案

很多人都会遇到这种问题，因为他们的代码是基于编写糟糕的教程。一个关键错误是在整形处理程序中进行投影矩阵设置。在任何正式的 OpenGL 应用程序中，包括游戏，您将在渲染期间多次切换投影 - 对于 HUD、迷你 map 、GUI 元素等。

相反，您在需要该投影之前在显示处理程序中设置投影。此外，您根本没有设置投影矩阵，您只设置了视口(viewport) - 关闭，但还不够。我不会调用显示处理程序 Ball_Loop，但是我会这样修改它:

void BallLoop()
{
     const int   win_width  = glutGet(GLUT_WINDOW_WIDTH);
     const int   win_height = glutGet(GLUT_WINDOW_HEIGHT);
     const float win_aspect = (float)win_width/(float)win_height;

     glClearColor(1.0,1.0,1.0,0);
     glDisable(GL_DEPTH_TEST);
     glClear(GL_COLOR_BUFFER_BIT);

     glViewport(0, 0, win_width, win_height);
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
     glOrtho(-aspect, aspect, -1, 1, -1, 1); /* those ortho limits should match your game logic */

     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
     c_draw();
     b_draw();
     p_draw();
     glFlush();
     if(started)
                c_move();
     if(crashed())
     {           
                 x_pos = 0;
                 y_pos = -0.7;
                 started = 0;
                 UP = 1;
                 RIGHT = 1;
                 DOWN = 0;
                 LEFT = 0;
     }

     glutSwapBuffers();
     glutPostRedisplay();
}

编辑 完全修复和可玩的 brickbreaker.cc 源代码

#include <GL/glut.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <cmath>

using namespace std;

#define RADIUS 0.025

#define RATIO (4./3.)

bool show[5][10];
float x_brick[4][9];
float y_brick[4][9];

float paddle_x = 0;
float paddle_y = -0.8;
float paddle_speed = 0;
const float PaddleSpeedFactor = 3.;

bool phit_center = false , phit_corner = false;
bool game_over = false;

float speed_x = 0.;
float speed_y = 0.;

float x_pos = 0,y_pos = -0.75;
int lives  = 3;

float T_last_frame = 0.;

void draw_bricks()
{
      glColor3f(1.0,0.0,0.0);
      glBegin(GL_QUADS);
      for(int a = 0; a < 9; a++)
      {
              for(int b = 0; b < 4; b++)
              {
                      if(show[b][a] == 1)
                      {
                                    glVertex2f(x_brick[b][a],y_brick[b][a]);
                                    glVertex2f(x_brick[b][a],y_brick[b][a] - 0.10); 
                                    glVertex2f(x_brick[b][a]+0.2,y_brick[b][a] - 0.10);
                                    glVertex2f(x_brick[b][a]+0.2,y_brick[b][a]);  
                      }
              }
      }
      glEnd();
}

void ball_draw()
{
     glColor3f(0.0,0.0,0.0);
     glBegin(GL_TRIANGLE_FAN);
     glVertex2f(x_pos,y_pos);
     for (float angle = 0; angle < (10); angle+=0.01)
     {
         glVertex2f((x_pos + sin(angle) * RADIUS), (y_pos + (cos(angle)) * RADIUS));
     }
     glEnd();
}

bool brick_hit()
{
     bool hit = false;
     int flag = 1;
     for(int a = 0; a < 10; a++)
     {
             for(int b =0; b < 4; b++)
             {
                     if(x_pos >= x_brick[b][a] && x_pos <= x_brick[b][a] + 0.2)
                     {
                              if(y_pos <= y_brick[b][a] && y_pos >= y_brick[b][a] - 0.1)
                              {
                                       if(show[b][a] == 1)
                                       {
                                                     show[b][a] = 0;
                                                     flag = 0;
                                                     hit = true;
                                                     break;
                                       }
                              }
                     }
             }
             if(flag == 0)
                     break;
     }
     return hit;
}

bool crashed()
{
     if(y_pos < paddle_y - 0.05)
              return true;

     return false;
}

void paddle_hit()
{
     phit_corner = false;
     phit_center = false;
     if(x_pos <= paddle_x + 0.13 && x_pos >= paddle_x - 0.13)
     {
              if(y_pos <= paddle_y)
              {
                       phit_center = true;
              }
     }
     else if( (x_pos >= paddle_x + 0.13 && x_pos <= paddle_x + 0.2) || 
                  (x_pos <= paddle_x - 0.13 && x_pos >= paddle_x - 0.2))
     {
               if(y_pos <= paddle_y)
               {
                        phit_corner = true;
               }
     }
}

void paddle_move(float dT)
{

    if(paddle_x < RATIO && paddle_x > -RATIO)
        paddle_x += paddle_speed * PaddleSpeedFactor * dT;

        if( paddle_x > 0.95) {
        paddle_x = 0.95;
        paddle_speed = 0.;
    }

        if( paddle_x < -0.95) {
        paddle_x = -0.95;
        paddle_speed = 0.;
    }

    paddle_speed *= (1. - 0.05);
    if( fabs(paddle_speed) < 0.01 )
        paddle_speed = 0.;
}

void ball_move(float dT)
{
      x_pos += speed_x * dT;
      y_pos += speed_y * dT;

      if( brick_hit() ) {
        speed_y *= -1;
      }

      if( x_pos >= (RATIO-RADIUS) || x_pos <= (-RATIO+RADIUS ) )
      {
        speed_x *= -1;
      }

      if( y_pos >= (1.-RADIUS) )
      {
        speed_y = -1;
      }

      paddle_hit();
      if(phit_center)
      {
        speed_y = 1;
      }
      if(phit_corner)
      {
        speed_x *= -1;
        speed_y = 1;
      }
}

void paddle_draw()
{
     glColor3f(0.0,0.0,0.0);
     glBegin(GL_QUADS);
                      glVertex2f(paddle_x - 0.2, paddle_y);
                      glVertex2f(paddle_x + 0.2, paddle_y);
                      glVertex2f(paddle_x + 0.2, paddle_y - 0.05);
                      glVertex2f(paddle_x - 0.2, paddle_y - 0.05);
     glEnd();
}

void step_game()
{
     paddle_move(T_last_frame);
     ball_move(T_last_frame);

     if(crashed())
     {
    speed_x = 0;
    speed_y = 0; 
        x_pos = 0;
        y_pos = -0.7;
        paddle_speed = 0;
        paddle_x = 0;
     }

     glutPostRedisplay();
}

void launch_ball()
{
    speed_y = 1.;
    speed_x = 1.;
}

void user_input(unsigned char key, int x, int y)
{
     if(key == 13)
        launch_ball();
}

void ArrowKeys(int key, int x, int y)
{
     if(key==GLUT_KEY_LEFT)
        paddle_speed = -1.;

     if(key==GLUT_KEY_RIGHT)
        paddle_speed = +1.;
}

void set_xy()
{
    for(int a = 0; a < 5; a++)
    {
            for(int b = 0; b < 10; b++)
            {
                    show[a][b] = 1;
            }
    }
    int c = 0;
    for(float a = -0.94; c <= 8; a+=0.21)
    {         

              for(int b = 0; b <= 5; b++)
              {
                      x_brick[b][c] = a;

              }
              c++;
    }
    int d = 0;
    for(float s = 0.99; d <= 3; s-=0.11)
    {
              for(int  r = 0; r < 9; r++)
              {
                       y_brick[d][r] = s;
              }
              d++;
    }
}

void display()
{
    const int win_width  = glutGet(GLUT_WINDOW_WIDTH);
    const int win_height = glutGet(GLUT_WINDOW_HEIGHT);
    const float win_aspect = (float)win_width / (float)win_height;

    glViewport(0, 0, win_width, win_height);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if(win_aspect > RATIO) {
        glOrtho(-win_aspect, win_aspect, -1., 1., -1., 1.);
    } else {
        glOrtho(-RATIO, RATIO, -RATIO/win_aspect, RATIO/win_aspect, -1., 1.);
    }

    glMatrixMode(GL_MODELVIEW);

    glClearColor(0., 0., 1., 1.);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glBegin(GL_QUADS);
        glColor3f(1,1,1);
        glVertex2f(-RATIO, -1);
        glVertex2f(RATIO, -1);
        glVertex2f(RATIO, 1);
        glVertex2f(-RATIO, 1);
        glEnd();

    draw_bricks();
    paddle_draw();
    ball_draw();

    glutSwapBuffers();

        // GLUT doesn't offer cross plattform timing
        // assume 60Hz refresh rate
        T_last_frame = 1./60.;
}

int main(int argc, char **argv)
{
    set_xy();

    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);

    glutInitWindowPosition(0,0);
    glutInitWindowSize(800, 600);

    glutCreateWindow("Brick Breaker - By Viraj");
    glutDisplayFunc(display);

    glutKeyboardFunc(user_input);
    glutSpecialFunc(ArrowKeys);

    glutIdleFunc(step_game);

    glutMainLoop(); 

    return 0;
}

EDIT 2 为了完整起见，这是一个 GLFW 版本

#include <GL/glfw.h>

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

using namespace std;

#define RADIUS 0.025

#define RATIO (4./3.)

bool show[5][10];
float x_brick[4][9];
float y_brick[4][9];

const float SpeedFactor = 10.;

float paddle_x = 0;
float paddle_y = -0.8;
float paddle_speed = 0;
const float PaddleSpeedFactor = 3.;

bool phit_center = false, phit_corner = false;
bool game_over = false;

float speed_x = 0.;
float speed_y = 0.;

float x_pos;
float y_pos;
int lifes = 0;

void draw_bricks()
{
    glColor3f(1.0, 0.0, 0.0);
    glBegin(GL_QUADS);
    for (int a = 0; a < 9; a++) {
        for (int b = 0; b < 4; b++) {
            if (show[b][a] == 1) {
                glVertex2f(x_brick[b][a], y_brick[b][a]);
                glVertex2f(x_brick[b][a], y_brick[b][a] - 0.10);
                glVertex2f(x_brick[b][a] + 0.2,
                       y_brick[b][a] - 0.10);
                glVertex2f(x_brick[b][a] + 0.2, y_brick[b][a]);
            }
        }
    }
    glEnd();
}

void ball_draw()
{
    glColor3f(0.0, 0.0, 0.0);
    glBegin(GL_TRIANGLE_FAN);
    glVertex2f(x_pos, y_pos);
    for (float angle = 0; angle < (10); angle += 0.01) {
        glVertex2f((x_pos + sin(angle) * RADIUS),
               (y_pos + (cos(angle)) * RADIUS));
    }
    glEnd();
}

bool brick_hit()
{
    for (int a = 0; a < 10; a++) {
        for (int b = 0; b < 4; b++) {
            if (x_pos >= x_brick[b][a]
                && x_pos <= x_brick[b][a] + 0.2) {
                if (y_pos <= y_brick[b][a]
                    && y_pos >= y_brick[b][a] - 0.1) {
                    if (show[b][a] == 1) {
                        show[b][a] = 0;
                        return true;
                    }
                }
            }
        }
    }
    return false;
}

bool crashed()
{
    if (y_pos < paddle_y - 0.05)
        return true;

    return false;
}

void paddle_hit()
{
    phit_corner = false;
    phit_center = false;
    if (x_pos <= paddle_x + 0.13 && x_pos >= paddle_x - 0.13) {
        if (y_pos <= paddle_y) {
            phit_center = true;
        }
    } else if ((x_pos >= paddle_x + 0.13 && x_pos <= paddle_x + 0.2) ||
           (x_pos <= paddle_x - 0.13 && x_pos >= paddle_x - 0.2)) {
        if (y_pos <= paddle_y) {
            phit_corner = true;
        }
    }
}

void paddle_move(float dT)
{

    if (paddle_x < RATIO && paddle_x > -RATIO)
        paddle_x += paddle_speed * PaddleSpeedFactor * dT;

    if (paddle_x > 1.) {
        paddle_x = 1.;
        paddle_speed = 0.;
    }

    if (paddle_x < -1.) {
        paddle_x = -1.;
        paddle_speed = 0.;
    }
}

void ball_move(float dT)
{
    x_pos += speed_x * dT;
    y_pos += speed_y * dT;

    if (brick_hit()) {
        speed_y *= -1;
    }

        if (x_pos >= (RATIO - RADIUS) || x_pos <= (-RATIO + RADIUS)) {
        speed_x *= -1;
    }

    if (y_pos >= (1. - RADIUS)) {
        speed_y = -1;
    }

    paddle_hit();
    if (phit_center) {
        speed_y = 1;
    }
    if (phit_corner) {
        speed_x *= -1;
        speed_y = 1;
    }
}

void paddle_draw()
{
    glColor3f(0.0, 0.0, 0.0);
    glBegin(GL_QUADS);
    glVertex2f(paddle_x - 0.2, paddle_y);
    glVertex2f(paddle_x + 0.2, paddle_y);
    glVertex2f(paddle_x + 0.2, paddle_y - 0.05);
    glVertex2f(paddle_x - 0.2, paddle_y - 0.05);
    glEnd();
}

void reset_game()
{
    lifes = 3;
    speed_x = 0;
    speed_y = 0;
    x_pos = 0;
    y_pos = -0.7;
    paddle_speed = 0;
    paddle_x = 0;
}

void step_game(float dT)
{
    if(!lifes)
        return;

    paddle_move(dT * SpeedFactor);
    ball_move(dT * SpeedFactor);

    if (crashed()) {
        lifes--;
        speed_x = 0;
        speed_y = 0;
        x_pos = 0;
        y_pos = -0.7;
    }
}

void launch_ball()
{
    if(!lifes)
        return;

    speed_y = 1.;
    speed_x = 1.;
}

void keyboard(int key, int action)
{
    switch(key) 
    {
    case GLFW_KEY_ENTER:
        launch_ball();
        break;

    case GLFW_KEY_ESC:
        reset_game();
        break;

    case GLFW_KEY_LEFT:
        switch(action) {
        case GLFW_PRESS:
            paddle_speed = -1.;
            break;

        case GLFW_RELEASE:
            paddle_speed = 0;
            break;
        } break;

    case GLFW_KEY_RIGHT:
        switch(action) {
        case GLFW_PRESS:
            paddle_speed = 1.;
            break;

        case GLFW_RELEASE:
            paddle_speed = 0;
            break;
        } break;
    }
}

void set_xy()
{
    for (int a = 0; a < 5; a++) {
        for (int b = 0; b < 10; b++) {
            show[a][b] = 1;
        }
    }
    int c = 0;
    for (float a = -0.94; c <= 8; a += 0.21) {

        for (int b = 0; b <= 5; b++) {
            x_brick[b][c] = a;

        }
        c++;
    }
    int d = 0;
    for (float s = 0.99; d <= 3; s -= 0.11) {
        for (int r = 0; r < 9; r++) {
            y_brick[d][r] = s;
        }
        d++;
    }
}

float display()
{
    int win_width;
    int win_height;
    glfwGetWindowSize(&win_width, &win_height);
    const float win_aspect = (float)win_width / (float)win_height;

    glfwSetTime(0.);

    glViewport(0, 0, win_width, win_height);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if (win_aspect > RATIO) {
        glOrtho(-win_aspect, win_aspect, -1., 1., -1., 1.);
    } else {
        glOrtho(-RATIO, RATIO, -RATIO / win_aspect, RATIO / win_aspect,
            -1., 1.);
    }

    glMatrixMode(GL_MODELVIEW);

    glClearColor(0., 0., 1., 1.);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glBegin(GL_QUADS);
    glColor3f(1, 1, 1);
    glVertex2f(-RATIO, -1);
    glVertex2f(RATIO, -1);
    glVertex2f(RATIO, 1);
    glVertex2f(-RATIO, 1);
    glEnd();

    draw_bricks();
    paddle_draw();

    ball_draw();

    glfwSwapBuffers();
    return glfwGetTime();
}

int main(int argc, char **argv)
{
    set_xy();

    if( GL_FALSE == glfwInit() )
        return -1;

    if( GL_FALSE == glfwOpenWindow(800, 600, 8, 8, 8, 8, 0, 0, GLFW_WINDOW) )
        return -2;

    glfwSetWindowTitle("Viraj's Brick Breaker - GLFW version by datenwolf");
    glfwSetKeyCallback(keyboard);

    reset_game();

    while( glfwGetWindowParam(GLFW_OPENED) ) {
        glfwPollEvents();
        float const dT = display();
        step_game(dT);
    }

    glfwTerminate();

    return 0;
}

关于c++ - 打砖 block 帮助。圆圈、划桨和笨拙的弹跳，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/6826000/

文章推荐： c++ - 带有 OpenGL 的 C++ 中的原始重启索引错误

文章推荐： c++ - 线程写入日志文件

文章推荐： c++ - 以 bitset 作为参数的模板类的问题

文章推荐： c++ - Bison 中的 Action 顺序

JavaScript "ball"弹跳
我是一个 JS 菜鸟。我正在进入浏览器游戏编程，并想制作一个球掉落和弹跳的快速示例以供学习。由于某种原因，当我创建 jsfiddle 时，我的代码实际上不起作用，我的 div id="ball"的 o
jQuery 弹跳变体(弹跳)
我正在努力寻找为此目的的插件/插件，它是我项目的关键部分，我忽略了它，现在它咬了我。我需要 jQuery 弹跳的变体，它使 div 无限期地围绕父 div/包装器弹跳。实际上，我将拥有一个屏幕，用
ios - UIView 弹跳？
我的 Nib 底部有一个 UIView。我希望它的高度能够增长，但让它看起来好像它没有移动位置，只是在增长。然后将高度缩小回原来的高度，除了高度之外不进行任何移动。不幸的是，它在 y 位置上反弹。它会
javascript - jquery scrollTop 弹跳
我做错了什么？我的技能栏正在跳舞。加载后我想修复它们。在这里检查我的笔:http://codepen.io/anon/pen/KdEeWW $(window).scroll(function() {
jQuery 在表格单元格内滚动(弹跳)长文本
我有一个有 2 列的表格，其中一列具有设定的宽度，第二列占据页面的其余部分。在第一列中，我有另一个包含 2 个 tr 元素的表(这是由 asp 生成的) 如此处所示的表格:http://jsfidd
jQuery 第三级 SlideToggle 弹跳
我正在使用 jQuery 构建基于标准 ul>li 结构的下拉导航。一切都运行良好，但是，当我到达三元级别项目时，slideToggle 函数会导致“反弹”并且永远不会显示子 UL 由于有相当多的代
c# - Unity3D:弹跳/反射光线转换
大家好，谢谢大家的帮助，我想做的事情相当简单，我想显示一个跟随我的弹跳/反射 Raycast 的线渲染器。这是我目前所拥有的。 private LineRenderer lr; public i
jquery - 几个问题(弹跳，对齐)
我试图对齐中间圆圈中的文本并让它们在圆圈悬停时弹跳(即文本) 这里是: http://jsfiddle.net/cJ3se/ 希望有人能帮忙丹佛最佳答案将元素中的单行文本垂直居中的最简单方法是将
css - 弹跳 webkit 动画
这很难解释，我来试一试。我目前有一个从右向左无休止地滑动的图像背景，就像传送带一样。图像用完时会重复。我试图让图像/动画在重复之前反弹(反向)。所以图像慢慢地向一个方向滑动，然后慢慢地向另一个方向
html - CSS 动画不工作(弹跳)
我想知道为什么我的弹跳动画在 JSFiddle 中不起作用但在我的开发网站上工作。请检查这个有什么问题。在我的开发站点中，箭头会弹跳但不会像我的 CSS 类中所说的那样旋转。 .active.ongo
python - 如何阻止皮蒙克关节的 body 弹跳？
我正在使用Pymunk模拟安装在细长腿顶部枢轴上的盒子的物理特性，该腿固定在地面上。连接盒子和腿的枢轴是 PivotJoint 和 SimpleMotor 的组合，模拟原始伺服系统，用户可以打开和关闭
ios - 弹跳 UIScrollView - 提示还有更多
我正在开发一个带有 ScrollView 的应用程序。不是很明显有更多内容，并且没有滚动指示器( ScrollView 被分页)。所以，为了给用户一个“嘿，这里有东西……”，我想让 ScrollVi
ios - 禁用屏幕顶部的 UIScrollView 弹跳
我的应用程序中有启用了垂直弹跳的 UIScrollView。我需要屏幕底部的弹跳，但没有在屏幕顶部启用。我不知道如何用以下方法检测 ScrollView : (void)scrollViewWi
jQuery UI - 弹跳 - 从左到右跳动的div
我的网站有问题，我在其中使用带有 jQuery UI 的 jQuery，在登录框上创建弹跳效果。但是，我对带有登录框的 div 有问题，因为它在屏幕左侧弹跳，当它应该在中间弹跳时，它在完成弹跳后
javascript - 在不禁用滚动功能的情况下防止 iOS 弹跳
当网页内容大于视口(viewport)时，我正在尝试实现一种解决方案，以防止 iOS 版 Safari 中的 iOS 反弹效果。我正在处理的页面在结构上非常具体，与此页面非常相似 http://ne
javascript - jQuery UI 弹跳(双图像)
第一次在这里发帖，如有任何标记问题请见谅。写帖子用SOF框架不习惯。我试图让一些社交图标在悬停时在我的网站上跳动。我从 jQuery UI 抓取代码进行测试并进行了一些小的编辑，但是我遇到了页面上可
iphone - 如果没有滚动距离，如何阻止 UIScrollView 弹跳？
我有一个 UIScrollView，我想在滚动时弹跳，但目前它能够弹跳，尽管内容大小与框架相同。如果内容大小和框架大小相同，如何阻止它弹跳？有没有比重写 setContentSize 和 setFra
javascript - jquery 在滚动时固定 div 弹跳
我的网页最右侧有一个 div (RightSide)，它位于另一个 div (TopBanner) 的正下方。即使用户向下滚动，TopBanner div 也会保持其在屏幕顶部的准确位置。正是我想要的
ios - UIButton 使 UIScrollView 弹跳
我有一个带分页的水平 UIScrollView。有两个按钮。一个向左滚动 scrollView，另一个向右滚动。左边的代码: - (IBAction)goLeftAction:(id)sender
ios - 如何创建具有不同页面大小的 UIScrollView(页面对齐、弹跳)
我正在尝试创建自定义垂直 UIScrollView，它可以处理具有不同页面高度的多个页面。假设: 页面高度等于或大于屏幕高度如果页面高于屏幕高度，它会像往常一样滚动 UIScrollView –

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c++ - 打砖 block 帮助。圆圈、划桨和笨拙的弹跳