开发者

Brick Breaker help. circles, paddles, and awkward bouncing

开发者 https://www.devze.com 2023-03-22 17:53 出处：网络
I\'ve written a simple brick breaker game in OpenGL. The ball is a 2D circle drawn using : for (float angle = 0; angle < (10); angle+=0.01)
相关专题：geometrygraphicsopengl

I've written a simple brick breaker game in OpenGL. The ball is a 2D circle drawn using :

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

This causes distortion when the game is changed to fullscreen. RADIUS is defined as 0.025 . I need help in making the paddle movements smooth as well. Also, if you play the game a couple of times, you'll notice that towards the extreme left, when the ball hits the paddle, it rises to a certain height and then bounces back down. Full code:

#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_bri开发者_StackOverflow社区ck[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;
}

A lot of people run into this kind of issue, because they base their code on badly written tutorials. One key mistake is to do the projection matrix setup in the reshape handler. In any serious OpenGL application, games including, you will switch the projection several times during rendering – for HUDs, minimaps, GUI elements etc.

Instead you set projection in the display handler, right before you need that projection. Also you missed to set the projection matrix at all, you only set the viewport - close, but not enough. I'd not call the display handler Ball_Loop, but well, here's how I'd modify it:

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();
}

EDIT fully fixed and playable brickbreaker.cc source code

#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 and just for the sake of completeness, here's a GLFW version

#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;
}

i think your distortion is due to your changeSize(...) function: you calculate the aspect ratio of of your window, but you do not use it. Have a look at the code where you stole this snippet from :)

Do you change resolution of your screen when switching to fullscreen mode? If you do, it is very likely that a pixel is not square anymore, so you will need the actual aspect ratio of your screen.

0

上一篇:

:下一篇

更多 问答 相关资讯：

精彩评论

暂无评论...
登录 注册
Qedev.com
验证码 换一张
取 消

    关注公众号

    热门标签

    图文推荐

    Delphi - Custom drawing a message list

    Delphi - Custom drawing a message list
    C++ header-only include pattern

    C++ header-only include pattern
    IE7 Margin Collapses Into Padding

    IE7 Margin Collapses Into Padding
    in CoffeeScript, how can I use a variable as a key in a hash?

    in CoffeeScript, how can I use a variable as a key in a hash?
    Interactive visualization of a graph in python [closed]

    Interactive visualization of a graph in python [closed]
    How to customise PHP MYSQL tables?

    How to customise PHP MYSQL tables?
    High quality, simple random password generator

    High quality, simple random password generator
    Image Recognition ApI in android

    Image Recognition ApI in android

    开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

    法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

    Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9