часики

#include <iostream>
#include <list>
#include <cmath>
#include <algorithm>
#include <vector>
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>

using namespace std;

double scale = 0.5;
double pi = 3.1415926;

/*int avg(vector<float> a){
    float res = 0;
    for (int i = 0; i < a.size(); i++)
        res += a[i];
    return (res / a.size());
}*/

float update_time = 20;
float angle_step = M_PI / 30.0 / 1000.0 * update_time;

class vec2d {
public:
    float x;
    float y;
    vec2d() : x(0), y(0) {}
    vec2d(float a,float b) : x(a), y(b){}
    void print(){
        cout << x << "\t" << y << endl;
    }
    float dot(vec2d other){
        return (x * other.x + y * other.y);
    }
    vec2d operator + (vec2d other){
        return vec2d(x + other.x, y + other.y);
    }
    vec2d operator - (vec2d other){
        return vec2d(x - other.x, y - other.y);
    }
    vec2d operator * (float a){
        return vec2d(x * a, y * a);
    }
    vec2d operator / (float a){
        return vec2d(x / a, y / a);
    }
};

void render_square(double x, double y) {
    glPushMatrix();

    double dx = 0.5;
    double dy = 0.5;
    glBegin(GL_POLYGON);
    glVertex2f(x, y);
    glVertex2f(x + dx, y);
    glVertex2f(x + dx, y - dy);
    glVertex2f(x, y - dy);
    glEnd();
    glPopMatrix();
}

void draw_line(double x, double y, double x1, double y1) {
    glBegin(GL_LINES);
    glVertex2d(x, y);
    glVertex2d(x1, y1);
    glEnd();
}
void draw_arrow(float x, float y, vec2d a){
    draw_line(x, y, a.x, a.y);
    vec2d n1(a.y * 0.3, -a.x * 0.3);
    vec2d n2(-a.y * 0.3, a.x * 0.3);
    vec2d z(-a.x, -a.y);
    vec2d zn1 = z + n1;
    vec2d zn2 = z + n2;
    draw_line(a.x, a.y, zn1.x / 6 + a.x, zn1.y / 6 + a.y);
    draw_line(a.x, a.y, zn2.x / 6 + a.x, zn2.y / 6 + a.y);
}
class Circle{
public:
    float x, y, radius, vx, vy;
    Circle(float cx, float cy, float vx, float vy, float r) : x(cx), y(cy), radius(r), vx(vx), vy(vy) {}
    void draw(){
        float step = 0.04;
        for (float f = 0; f <= M_PI * 2; f += step){
            draw_line(x + radius * cos(f), y + radius * sin(f), x + radius * cos(f+step), y + radius * sin(f+step));
        }
    }
    void draw_sticks(){
        static float cur_angle = -M_PI * 0.5;
        for (float i = 0; i < 2 * M_PI; i += M_PI / 30){
            if (i % 5 * (M_PI / 30) == 0)
                draw_line(cos(cur_angle), sin(cur_angle, cos(cur_angle) * 0.8, sin(cur_angle) * 0.8));
            else
        }

    }
};
Circle c(0, 0, 0, 0, 3);

void Render() {
        static float cur_angle = -M_PI * 0.5;
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();
        glTranslatef(0, 0, -10);
        glColor3d(1, 1, 1);
        glScalef(scale, scale, scale);
        vec2d arrow(3 * cos(-cur_angle),3 * sin(-cur_angle));
        draw_arrow(0, 0, arrow);
        cur_angle += angle_step;
        if (cur_angle > 2 * M_PI) cur_angle -= 2 * M_PI;
        c.draw();
        glFlush();
}

void update(int t) {
    Render();
    glutTimerFunc(update_time, update, 0);
}

void keyb(unsigned char key, int x, int y) {
    if(key == '+') {
        scale *= 1.1;
    }
    if(key == '-') {
        scale *= 0.9;
    }

    Render();
}

void reshape(int w, int h) {

    // предупредим деление на ноль
    // если окно сильно перетянуто будет
    if(h == 0)
        h = 1;
    float ratio = 1.0* w / h;

    // используем матрицу проекции
    glMatrixMode(GL_PROJECTION);

        // Reset матрицы
    glLoadIdentity();

    // определяем окно просмотра
    glViewport(0, 0, w, h);

    // установить корректную перспективу.
    gluPerspective(45,ratio,1,1000);

    // вернуться к модели
    glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(800, 600);
    glutCreateWindow("Physics Engine");
    glEnable(GL_DEPTH_TEST);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glClearColor(0., 0.4, 0.0, 0.0);

    glutTimerFunc(50, update, 0);
    glutReshapeFunc(reshape);
    glutDisplayFunc(Render);
    glutKeyboardFunc(keyb);
    glutMainLoop();
}