kookroach/game-physics
1
0
Fork 0
Code Issues 8 Pull Requests Packages Projects 1 Releases Wiki Activity

Merge pull request 'revert b1c4939b16a9ae408160e0d0d3dcd2a4872a1cb4' (#9) from revert-test into master

Browse Source 
Reviewed-on: #9
This commit is contained in:
Lukas Moungos
2023-11-16 21:27:42 +01:00
parent b1c4939b16 9316f35eee
commit 50d8f7561e
1 changed files with 141 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
Simulations/MassSpringSystemSimulator.cpp
View File

@@ -1,22 +1,17 @@
#include "MassSpringSystemSimulator.h" #include "MassSpringSystemSimulator.h"
#include <stdio.h>
MassSpringSystemSimulator::MassSpringSystemSimulator() MassSpringSystemSimulator::MassSpringSystemSimulator()
{ {
m_iTestCase = 0; m_iTestCase = 0;
m_fMass = 10; m_fMass = 10;
m_fStiffness = 40; m_fStiffness = 40;
int m_iIntegrater = 0; m_iIntegrator = EULER;
auto first = addMassPoint(Vec3(0, 0, 0), Vec3(-1, 0, 0), true);
auto second = addMassPoint(Vec3(0, 2, 0), Vec3(1, 0, 0), true);
addSpring(first, second, 1.0);
} }
const char* MassSpringSystemSimulator::getTestCasesStr() const char* MassSpringSystemSimulator::getTestCasesStr()
{ {
//hier to change the choices return "Demo1,Demo2,Demo3,Demo4";
return "Euler,LeapFrog,Midpoint";
} }
void MassSpringSystemSimulator::initUI(DrawingUtilitiesClass* DUC) void MassSpringSystemSimulator::initUI(DrawingUtilitiesClass* DUC)
@@ -24,13 +19,14 @@ void MassSpringSystemSimulator::initUI(DrawingUtilitiesClass* DUC)
this->DUC = DUC; this->DUC = DUC;
switch (m_iTestCase) switch (m_iTestCase)
{ {
case 0:break; case 0:
case 1: break;
case 1:
break; break;
case 2: case 2:
break; break;
default:break; default:
break;
} }
} }
@@ -39,10 +35,11 @@ void MassSpringSystemSimulator::reset()
m_mouse.x = m_mouse.y = 0; m_mouse.x = m_mouse.y = 0;
m_trackmouse.x = m_trackmouse.y = 0; m_trackmouse.x = m_trackmouse.y = 0;
m_oldtrackmouse.x = m_oldtrackmouse.y = 0; m_oldtrackmouse.x = m_oldtrackmouse.y = 0;
springs.clear();
masspoints.clear();
} }
void MassSpringSystemSimulator::drawFrame(ID3D11DeviceContext* pd3dImmediateContext) void MassSpringSystemSimulator::drawFrame(ID3D11DeviceContext* pd3dImmediateContext)
{ {
@@ -69,24 +66,91 @@ void MassSpringSystemSimulator::drawFrame(ID3D11DeviceContext* pd3dImmediateCont
void MassSpringSystemSimulator::notifyCaseChanged(int testCase) void MassSpringSystemSimulator::notifyCaseChanged(int testCase)
{ {
m_iTestCase = testCase; m_iTestCase = testCase;
system("cls");
reset();
switch (m_iTestCase) switch (m_iTestCase)
{ {
case 0: case 0: {
cout << "Euler !\n"; cout << "Demo 1 !\n";
setMass(10);
setStiffness(40);
//simulateTimestep(1); int first = addMassPoint(Vec3(0, 0, 0), Vec3(-1, 0, 0), true);
int second = addMassPoint(Vec3(0, 2, 0), Vec3(1, 0, 0), true);
addSpring(first, second, 1);
cout << "\t -- INITIAL --\n";
printSpring(springs.at(0));
cout << "--------------------------------------------------" << std::endl;
//calculate Euler for one step and print results
setIntegrator(EULER);
cout << "\n\n\t -- EULER RESULT --\n";
simulateTimestep(1);
printSpring(springs.at(0));
cout << "--------------------------------------------------" << std::endl;
reset();
first = addMassPoint(Vec3(0, 0, 0), Vec3(-1, 0, 0), true);
second = addMassPoint(Vec3(0, 2, 0), Vec3(1, 0, 0), true);
addSpring(first, second, 1);
//calculate Midpoint for one step and print results
setIntegrator(MIDPOINT);
cout << "\n\n\t -- MIDPOINT RESULT --\n";
simulateTimestep(1);
printSpring(springs.at(0));
break; break;
case 1: }
break;
case 2:
cout << "Midpoint \n";
//m_iNumSpheres = 100;
//m_fSphereSize = 0.05f;
break;
case 1: {
cout << "Demo 2 !\n";
reset();
int first = addMassPoint(Vec3(0, 0, 0), Vec3(-1, 0, 0), true);
int second = addMassPoint(Vec3(0, 2, 0), Vec3(1, 0, 0), true);
addSpring(first, second, 1.0);
cout << "\t -- INITIAL --\n";
printSpring(springs.at(0));
cout << "--------------------------------------------------" << std::endl;
//calculate Euler for a timestep of 0.005 and print results
setIntegrator(EULER);
cout << "\n\n\t -- EULER RESULT--\n";
simulateTimestep(0.005);
printSpring(springs.at(0));
break;
}
case 2: {
cout << "Demo 3 !\n";
reset();
int first = addMassPoint(Vec3(0, 0, 0), Vec3(-1, 0, 0), true);
int second = addMassPoint(Vec3(0, 2, 0), Vec3(1, 0, 0), true);
addSpring(first, second, 1.0);
cout << "\t -- INITIAL --\n";
printSpring(springs.at(0));
cout << "--------------------------------------------------" << std::endl;
//calculate Midpoint for a timestep of 0.005 and print results
setIntegrator(MIDPOINT);
cout << "\n\n\t -- MIDPOINT RESULT --\n";
simulateTimestep(0.005);
printSpring(springs.at(0));
break;
}
case 3: {
cout << "Demo 4 !\n";
break;
}
default: default:
//cout << "Demo4 !\n";
break; break;
} }
} }
@@ -114,29 +178,29 @@ void MassSpringSystemSimulator::externalForcesCalculations(float timeElapsed)
} }
void MassSpringSystemSimulator::simulateTimestep(float timeStep) void MassSpringSystemSimulator::simulateTimestep(float timeStep)
{ {
//update current setup for each frame //update current setup for each frame
switch (m_iTestCase) { for (size_t i = 0; i < springs.size(); i++) {
case 0: auto sp = springs.at(i);
//update the masspoint if (!sp.isValid())
cout << "Euler \n"; {
Euler(0, 1, 0, timeStep); springs.erase(springs.begin() + i);
continue;
}
break; if (m_iIntegrator == EULER) {
case 1:
break; Euler(sp, timeStep);
}
else if (m_iIntegrator == MIDPOINT) {
Midpoint(sp, timeStep);
}
else if (m_iIntegrator == LEAPFROG) {
//TODO: Add Leapfrog
}
case 2:cout << "midpoint \n";
Midpoint(0, 1, timeStep);
break;
default: break;
} }
//Euler(0, 1, 0, timeStep);
} }
void MassSpringSystemSimulator::onClick(int x, int y) void MassSpringSystemSimulator::onClick(int x, int y)
@@ -245,16 +309,17 @@ Vec3 MassSpringSystemSimulator::calculateAcceleration(Vec3 force, float mass)
return force / mass; return force / mass;
} }
void MassSpringSystemSimulator::Midpoint(int index1, int index2, float timestep) { void MassSpringSystemSimulator::Midpoint(Spring& spring, float timestep) {
//here some implementation about Midpoint //here some implementation about Midpoint
auto massPoint1 = masspoints.at(index1); auto massPoint1 = spring.mp1.lock();
auto massPoint2 = masspoints.at(index2); auto massPoint2 = spring.mp2.lock();
//old position //old position
auto mp = massPoint1->position; auto mp = massPoint1->position;
auto mp2 = massPoint2 ->position; auto mp2 = massPoint2->position;
//old Velocity //old Velocity
auto mOld_v = massPoint1->velocity; auto mOld_v = massPoint1->velocity;
auto m2Old_v = massPoint1->velocity; auto m2Old_v = massPoint2->velocity;
Vec3 PosVector = mp - mp2; Vec3 PosVector = mp - mp2;
//Abstand ausrechnen //Abstand ausrechnen
@@ -263,7 +328,7 @@ void MassSpringSystemSimulator::Midpoint(int index1, int index2, float timestep)
Vec3 PosNorm1 = PosVector / d; Vec3 PosNorm1 = PosVector / d;
Vec3 PosNorm2 = -1 * PosNorm1; Vec3 PosNorm2 = -1 * PosNorm1;
Vec3 Force = -m_fStiffness * (d - springs.at(0).initialLength) * PosNorm1; Vec3 Force = -m_fStiffness * (d - spring.initialLength) * PosNorm1;
Vec3 Force2 = -1 * Force; Vec3 Force2 = -1 * Force;
Vec3 oldAcc = calculateAcceleration(Force,m_fMass); Vec3 oldAcc = calculateAcceleration(Force,m_fMass);
@@ -282,37 +347,46 @@ void MassSpringSystemSimulator::Midpoint(int index1, int index2, float timestep)
Vec3 NewVel = mOld_v + timestep * oldAcc; Vec3 NewVel = mOld_v + timestep * oldAcc;
Vec3 NewVel2 = m2Old_v + timestep * oldAcc2; Vec3 NewVel2 = m2Old_v + timestep * oldAcc2;
//cout << NewPos;
cout << NewPos; //cout << NewVel;
cout << NewVel;
massPoint1->position = NewPos; massPoint1->position = NewPos;
massPoint1->velocity = NewVel; massPoint1->velocity = NewVel;
massPoint2->position = NewPos2; massPoint2->position = NewPos2;
massPoint2->velocity = NewVel2; massPoint2->velocity = NewVel2;
} }
void MassSpringSystemSimulator::Euler(int index1, int index2, int indexSpring, float timestep) void MassSpringSystemSimulator::Euler(Spring& spring, float timestep)
{ {
auto massPoint1 = spring.mp1.lock();
auto massPoint2 = spring.mp2.lock();
//take old position and send to calculatePositionTimestepEuler //take old position and send to calculatePositionTimestepEuler
auto mp = masspoints.at(index1); auto PosVector = massPoint1->position - massPoint2->position;
auto mp2 = masspoints.at(index2);
Vec3 PosVector = mp->position - mp2->position;
auto lengthVector = sqrt(PosVector.x * PosVector.x + PosVector.y * PosVector.y + PosVector.z * PosVector.z); auto lengthVector = sqrt(PosVector.x * PosVector.x + PosVector.y * PosVector.y + PosVector.z * PosVector.z);
auto normalized = PosVector / lengthVector; auto normalized = PosVector / lengthVector;
// Actual Calculation // Actual Calculation
// Force of spring is -k * (l - L) * normalizedVector [for P2 we can take -F1) // Force of spring is -k * (l - L) * normalizedVector [for P2 we can take -F1)
auto force = -m_fStiffness * (lengthVector - springs.at(0).initialLength) * normalized; auto force = -m_fStiffness * (lengthVector - spring.initialLength) * normalized;
auto foreP2 = -1 * force; auto foreP2 = -1 * force;
auto veloc = calculateVelocityTimestepEuler(mp->velocity, timestep, calculateAcceleration(force, 10.)); auto veloc = calculatePositionTimestepEuler(massPoint1->velocity, timestep, calculateAcceleration(force, 10.));
auto pos = calculatePositionTimestepEuler(mp->position, timestep, veloc); auto pos = calculatePositionTimestepEuler(massPoint1->position, timestep, veloc);
auto veloc2 = calculateVelocityTimestepEuler(mp2->velocity, timestep, calculateAcceleration(foreP2, 10.)); auto veloc2 = calculateVelocityTimestepEuler(massPoint2->velocity, timestep, calculateAcceleration(foreP2, 10.));
auto pos2 = calculatePositionTimestepEuler(mp2->position, timestep, veloc2); auto pos2 = calculatePositionTimestepEuler(massPoint2->position, timestep, veloc2);
// Update Positions and Velocity // Update Positions and Velocity
mp->position = pos; massPoint1->position = pos;
mp->velocity = veloc; massPoint1->velocity = veloc;
mp2->position = pos2;
mp2->velocity = veloc2; massPoint2->position = pos2;
massPoint2->velocity = veloc2;
}
void MassSpringSystemSimulator::printSpring(const Spring& spring)
{
auto mp1 = spring.mp1.lock();
auto mp2 = spring.mp2.lock();
printf("Masspoint 1:\nPosition: %s \nVelocity: %s\n\n", mp1->position.toString().c_str(), mp1->velocity.toString().c_str());
printf("Masspoint 2:\nPosition: %s \nVelocity: %s\n", mp2->position.toString().c_str(), mp2->velocity.toString().c_str());
} }