Keskustelu: Ohjelmointikysymykset: C++: Kolmiofysiikkaa

#include <SDL/SDL.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <iostream.h>
#include <fstream.h>

#define pii 3.1415926535
#define rad pii*2
class mouse_ {
  public:
  int button, x, y, prev_x, prev_y;
  float speed;
};
class vertex_ {
  public:
  float x, y;
  float angle;
  float radius;
};
class triangle_ {
  public:
  vertex_ vertex[3];
  vertex_ center;
  float angle;
  float rotation_speed;
  float speed_x, speed_y;

  void Draw();
  void SetCenter();
  void SetAngle();
  void SetPos();
  void CheckCollision(float x, float y, float speed);
};

bool PointInTriangle(float x, float y, float x1, float y1, float x2, float y2, float x3, float y3);
float Length(float x1, float y1, float x2, float y2);
float Angle(float x, float y, float x2, float y2);

int main(int argc, char *argv[]){
  SDL_Event event;
  float theta = 0.0f;

  SDL_Init(SDL_INIT_VIDEO);
  SDL_SetVideoMode(800, 600, 0, SDL_OPENGL | SDL_HWSURFACE );

  SDL_WM_SetCaption("Kolmiofysiikkaa", NULL);

  glOrtho(0,800, 600,0,-1,1);

  glViewport(0, 0, 800, 600);
  glClearDepth(1.0);
  glDepthFunc(GL_LESS);
  glEnable(GL_DEPTH_TEST);
  glShadeModel(GL_SMOOTH);
  glMatrixMode(GL_PROJECTION);
  glMatrixMode(GL_MODELVIEW);

  mouse_ mouse;

  SDL_Event e;
  int quit = 1;

  triangle_ kolmio;
  triangle_ kolmio2;

  kolmio.vertex[0].x = 22; kolmio.vertex[0].y = 30;
  kolmio.vertex[1].x = 40; kolmio.vertex[1].y = 10;
  kolmio.vertex[2].x = 60; kolmio.vertex[2].y = 30;

  kolmio.rotation_speed = 0;
  kolmio.angle = 0;
  kolmio.SetCenter();

  kolmio.center.x = 400;
  kolmio.center.y = 300;

  kolmio2.vertex[0].x = 22; kolmio2.vertex[0].y = 30;
  kolmio2.vertex[1].x = 40; kolmio2.vertex[1].y = 10;
  kolmio2.vertex[2].x = 60; kolmio2.vertex[2].y = 30;

  kolmio2.rotation_speed = 0;
  kolmio2.angle = 0;
  kolmio2.SetCenter();

  kolmio2.center.x = 400;
  kolmio2.center.y = 150;

  kolmio2.speed_y = 0.5;

  while (quit) {
    while (SDL_PollEvent(&e)) {
      if (e.type == SDL_QUIT) {
        quit = 0;
        }
      }

    mouse.prev_x = mouse.x;
    mouse.prev_y = mouse.y;

    mouse.button=SDL_GetMouseState(&mouse.x, &mouse.y);
    mouse.speed = Length(mouse.prev_x, mouse.prev_y, mouse.x, mouse.y);

    Uint8* keyboard;
    keyboard = SDL_GetKeyState(NULL);

    if(keyboard[SDLK_RIGHT]) kolmio.rotation_speed += rad/10000;
    if(keyboard[SDLK_LEFT]) kolmio.rotation_speed -= rad/10000;
    if(keyboard[SDLK_UP]) kolmio.speed_x += 0.01;
    if(keyboard[SDLK_DOWN]) kolmio.speed_x -= 0.01;
    if(keyboard[SDLK_ESCAPE]) quit = 0;

    for(int i=0; i<=2; i++)
      kolmio.CheckCollision(kolmio2.vertex[i].x, kolmio2.vertex[i].y, 2);

    kolmio.SetAngle();
    kolmio2.SetAngle();
    kolmio.SetPos();
    kolmio2.SetPos();

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClearDepth(1.0);
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

    kolmio.Draw();
    kolmio2.Draw();

    SDL_GL_SwapBuffers();
  }
  SDL_Quit();

  return 0;
}
void triangle_ :: SetCenter() {
  center.x = (vertex[0].x + vertex[1].x + vertex[2].x) / 3; center.y = (vertex[0].y + vertex[1].y + vertex[2].y) / 3;

  speed_x = 0;
  speed_y = 0;
  rotation_speed = 0;
  angle = 0;
  for(int i=0; i<=2; i++){
    vertex[i].radius = Length(center.x, center.y, vertex[i].x, vertex[i].y);
    vertex[i].angle = Angle(center.x, center.y, vertex[i].x, vertex[i].y);
  }
}
void triangle_ :: Draw (){
  glBegin(GL_LINE_STRIP);
    for(int i=0; i<=2; i++){
      glVertex2f(vertex[i].x, vertex[i].y);
    }
    glVertex2f(vertex[0].x, vertex[0].y);
  glEnd();
}
void triangle_ :: SetAngle(){
  angle += rotation_speed;
  for(int i=0; i<=2; i++){
    vertex[i].x = (sin(vertex[i].angle + angle)*vertex[i].radius) + center.x;
    vertex[i].y = (cos(vertex[i].angle + angle)*vertex[i].radius) + center.y;
  }
}
void triangle_ :: SetPos(){
    center.x += speed_x;
    center.y += speed_y;
}
void triangle_ :: CheckCollision(float x, float y, float speed){
  if(PointInTriangle(x, y, vertex[0].x, vertex[0].y, vertex[1].x, vertex[1].y, vertex[2].x, vertex[2].y) == true){
      int closest_vertex = 0;
      int second_closest_vertex = 1;
      float least_radius = Length(x, y, vertex[closest_vertex].x, vertex[closest_vertex].y);
      float second_least_radius = Length(x, y, vertex[second_closest_vertex].x, vertex[second_closest_vertex].y);

      for(int i = 1; i<=2; i++){
        if(Length(vertex[i].x, vertex[i].y, vertex[closest_vertex].x, vertex[closest_vertex].y) < least_radius){
           least_radius = Length(x, y, vertex[i].x, vertex[i].y);
           closest_vertex = i;
        }
        else if(Length(vertex[i].x, vertex[i].y, vertex[second_closest_vertex].x, vertex[second_closest_vertex].y) < second_least_radius){
           second_least_radius = Length(x, y, vertex[i].x, vertex[i].y);
           second_closest_vertex = i;
        }
      }

      speed_x = sin(Angle(vertex[closest_vertex].x, vertex[closest_vertex].y, vertex[second_closest_vertex].x, vertex[second_closest_vertex].y))*speed;
      speed_y = cos(Angle(vertex[closest_vertex].x, vertex[closest_vertex].y, vertex[second_closest_vertex].x, vertex[second_closest_vertex].y))*speed;
  }
}
bool PointInTriangle(float x, float y, float x1, float y1, float x2, float y2, float x3, float y3)
{
	float ab,bc,ca;
	ab = ((y - y1) * (x2 - x1) - (x - x1) * (y2 - y1)) / 1000.0f;
	bc = ((y - y2) * (x3 - x2) - (x - x2) * (y3 - y2)) / 1000.0f;
	ca = ((y - y3) * (x1 - x3) - (x - x3) * (y1 - y3)) / 1000.0f;
	if((ab * bc) > 0.0f && (bc * ca) > 0.0f) return true;
	return false;
}
float Length(float x1, float y1, float x2, float y2){
    return sqrt(abs(y2-y1)*abs(y2-y1)+abs(x2-x1)*abs(x2-x1));
}
float Angle(float x, float y, float x2, float y2){
  float a = x2 - x, B = y2 - y;
  float Angle, k;

  if (a == 0) {
    if (B < 0) k == 0; else k = pii;
  }
  else if (B == 0){
    if (a < 0) k = pii * 1.5; else k = pii * 0.5;
  }
  else {
    k = atan(B / a);
    k = k + pii * 0.5;
    if (a < 0) k = k + pii;
  }

  Angle = k;
  return Angle;
}