PositionBasedDynamics/Simulation/Simulation.cpp at master · shadercoder/PositionBasedDynamics · 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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include "Simulation.h"
#include "TimeManager.h"
#include "Utils/Timing.h"
#include "TimeStep.h"
#include "TimeStepController.h"

using namespace PBD;
using namespace std;
using namespace GenParam;

Simulation* Simulation::current = nullptr;
int Simulation::GRAVITATION = -1;
int Simulation::SIMULATION_METHOD = -1;
int Simulation::ENUM_SIMULATION_PBD = -1;
int Simulation::ENUM_SIMULATION_XPBD = -1;
int Simulation::ENUM_SIMULATION_IBDS = -1;

Simulation::Simulation ()
{
	m_gravitation = Vector3r(0.0, -9.81, 0.0);

	m_timeStep = nullptr;
	m_simulationMethod = SimulationMethods::NumSimulationMethods;
	m_simulationMethodChanged = NULL;
}

Simulation::~Simulation ()
{
	delete m_timeStep;
	delete TimeManager::getCurrent();

	current = nullptr;
}

Simulation* Simulation::getCurrent ()
{
	if (current == nullptr)
	{
		current = new Simulation ();
		current->init();
	}
	return current;
}

void Simulation::setCurrent (Simulation* tm)
{
	current = tm;
}

bool Simulation::hasCurrent()
{
	return (current != nullptr);
}

void Simulation::init()
{
	initParameters();
	setSimulationMethod(static_cast<int>(SimulationMethods::PBD));
}

void Simulation::initParameters()
{
	ParameterObject::initParameters();

 	GRAVITATION = createVectorParameter("gravitation", "Gravitation", 3u, m_gravitation.data());
 	setGroup(GRAVITATION, "Simulation");
 	setDescription(GRAVITATION, "Vector to define the gravitational acceleration.");

	ParameterBase::GetFunc<int> getSimulationFct = std::bind(&Simulation::getSimulationMethod, this);
	ParameterBase::SetFunc<int> setSimulationFct = std::bind(&Simulation::setSimulationMethod, this, std::placeholders::_1);
	SIMULATION_METHOD = createEnumParameter("simulationMethod", "Simulation method", getSimulationFct, setSimulationFct);
	setGroup(SIMULATION_METHOD, "Simulation");
	setDescription(SIMULATION_METHOD, "Simulation method.");
	EnumParameter* enumParam = static_cast<EnumParameter*>(getParameter(SIMULATION_METHOD));
	enumParam->addEnumValue("Position-Based Dynamics (PBD)", ENUM_SIMULATION_PBD);
	enumParam->addEnumValue("eXtended Position-Based Dynamics (XPBD)", ENUM_SIMULATION_XPBD);
	enumParam->addEnumValue("Impulse-Based Dynamic Simulation (IBDS)", ENUM_SIMULATION_IBDS);
}

void Simulation::reset()
{
	m_model->reset();
	if (m_timeStep)
		m_timeStep->reset();

	TimeManager::getCurrent()->setTime(static_cast<Real>(0.0));
	TimeManager::getCurrent()->setTimeStepSize(static_cast<Real>(0.005));
}

void Simulation::setSimulationMethod(const int val)
{
	SimulationMethods method = static_cast<SimulationMethods>(val);
	if ((method < SimulationMethods::PBD) || (method >= SimulationMethods::NumSimulationMethods))
		method = SimulationMethods::PBD;

	if (method == m_simulationMethod)
		return;

	delete m_timeStep;
	m_timeStep = nullptr;

	m_simulationMethod = method;

	if (method == SimulationMethods::PBD)
	{
		m_timeStep = new TimeStepController();
		m_timeStep->init();
		TimeManager::getCurrent()->setTimeStepSize(static_cast<Real>(0.005));
	}
	else if (method == SimulationMethods::XPBD)
	{
		LOG_INFO << "XPBD not implemented yet.";
	}
	else if (method == SimulationMethods::IBDS)
	{
		LOG_INFO << "IBDS not implemented yet.";
	}

	if (m_simulationMethodChanged != nullptr)
		m_simulationMethodChanged();
}

void Simulation::setSimulationMethodChangedCallback(std::function<void()> const& callBackFct)
{
	m_simulationMethodChanged = callBackFct;
}