COG/Simulator.cpp at master · AntoninRousset/COG · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#include "Simulator.h"

static Simulator *self;

// Constructors
Simulator::Simulator() :
	univers(nullptr), FPS(0), refreshCounter(REPORT_FPS), tickCounter(0),
	lastPhysicReport(0), lastPhysic(0), actualPhysic(0), PPS(0),
	physicCounter(REPORT_PPS), lastRefreshReport(0), lastRefresh(0),
	actualRefresh(0), physicDelta(0)
{
        self = this;
}

Simulator::Simulator(Univers *theUnivers) :
	univers(theUnivers), FPS(0), refreshCounter(REPORT_FPS), tickCounter(0),
	lastPhysicReport(0), lastPhysic(0), actualPhysic(0), PPS(0),
	physicCounter(REPORT_PPS), lastRefreshReport(0), lastRefresh(0),
	actualRefresh(0), physicDelta(0)
{
        self = this;
}

void Simulator::printInfo() const
{
        std::cout << "FPS:"
                        << FPS
                        << std::endl
                  << "PPS:"
                        << PPS
                        << std::endl;

        univers->printInfo();
}

void Simulator::physic()
{
	int get = glutGet(GLUT_ELAPSED_TIME);
	if(get < 0) {
		logger_warn("Unable to get elapsed time");
		return;
	} else {
		actualPhysic = (unsigned int) get;
	}

        physicDelta = double(MINIMUM_PPS * (actualPhysic - lastPhysic) / 1000.0);

        if (physicDelta > 1) {
                physicDelta = 1;
                logger_warn("Lag occured"); // To manage
        }
        if (physicCounter >= REPORT_PPS) {
                measurePPS();
                physicCounter = 0;
        }

        univers->physic(physicDelta);

        physicCounter ++;
        lastPhysic = actualPhysic;
}

void Simulator::measurePPS()
{
        PPS = (1000 * REPORT_PPS) / (actualPhysic - lastPhysicReport);
        lastPhysicReport = actualPhysic;
}

void Simulator::refresh()
{
	int get = glutGet(GLUT_ELAPSED_TIME);
	if(get < 0) {
		logger_warn("Unable to get elapsed time");
		return;
	} else {
		actualRefresh = (unsigned int) get;
	}

        if (refreshCounter >= REPORT_FPS) {
                measureFPS();
                refreshCounter = 0;
        }

	if (!(tickCounter % 10))
		univers->refresh(Univers::LEVEL);
	else
		univers->refresh(Univers::NONE);

        refreshCounter++;
	tickCounter++;
        lastRefresh = actualRefresh;
}

void Simulator::measureFPS()
{
        FPS = (1000 * REPORT_FPS) / (actualRefresh - lastRefreshReport);
        lastRefreshReport = actualRefresh;
}

void tick()
{
        self->physic();
        self->refresh();
}