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

Reviewed-on: #9

Simulations/Demo_2022.vcxproj

@@ -224,12 +224,14 @@
     </FxCompile>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClCompile Include="MassSpringSystemSimulator.cpp" />
     <ClCompile Include="TemplateSimulator.cpp" />
     <ClCompile Include="util\FFmpeg.cpp" />
     <ClCompile Include="util\util.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="DrawingUtilitiesClass.h" />
+    <ClInclude Include="MassPoint.h" />
     <ClInclude Include="MassSpringSystemSimulator.h" />
     <ClInclude Include="Simulator.h" />
     <ClInclude Include="TemplateSimulator.h" />

Simulations/Demo_2022.vcxproj.filters

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <FxCompile Include="effect.fx" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="MassSpringSystemSimulator.cpp" />
+    <ClCompile Include="TemplateSimulator.cpp" />
+    <ClCompile Include="util\FFmpeg.cpp" />
+    <ClCompile Include="util\util.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="DrawingUtilitiesClass.h" />
+    <ClInclude Include="MassSpringSystemSimulator.h" />
+    <ClInclude Include="Simulator.h" />
+    <ClInclude Include="TemplateSimulator.h" />
+    <ClInclude Include="util\FFmpeg.h" />
+    <ClInclude Include="util\matrixbase.h" />
+    <ClInclude Include="util\quaternion.h" />
+    <ClInclude Include="util\timer.h" />
+    <ClInclude Include="util\util.h" />
+    <ClInclude Include="util\vectorbase.h" />
+    <ClInclude Include="MassPoint.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <Text Include="..\readme.txt" />
+  </ItemGroup>
+</Project>

Simulations/MassPoint.h

@@ -0,0 +1,8 @@
+#pragma once
+#include "util/vectorbase.h"
+
+struct MassPoint {
+	GamePhysics::Vec3 position;
+	GamePhysics::Vec3 velocity;
+	bool isFixed;
+};

Simulations/MassSpringSystemSimulator.cpp

@@ -0,0 +1,392 @@
+#include "MassSpringSystemSimulator.h"
+#include <stdio.h>
+
+MassSpringSystemSimulator::MassSpringSystemSimulator()
+{
+	m_iTestCase = 0;
+	m_fMass = 10;
+	m_fStiffness = 40;
+	m_iIntegrator = EULER;
+}
+
+const char* MassSpringSystemSimulator::getTestCasesStr()
+{
+	return "Demo1,Demo2,Demo3,Demo4";
+}
+
+void MassSpringSystemSimulator::initUI(DrawingUtilitiesClass* DUC)
+{
+	this->DUC = DUC;
+	switch (m_iTestCase)
+	{
+		case 0:
+			break;
+		case 1:
+			break;
+		case 2:
+			break;
+		default:
+			break;
+	}
+}
+
+void MassSpringSystemSimulator::reset()
+{
+	m_mouse.x = m_mouse.y = 0;
+	m_trackmouse.x = m_trackmouse.y = 0;
+	m_oldtrackmouse.x = m_oldtrackmouse.y = 0;
+
+	springs.clear();
+	masspoints.clear();
+}
+
+void MassSpringSystemSimulator::drawFrame(ID3D11DeviceContext* pd3dImmediateContext)
+{
+	
+	for (size_t i = 0; i < springs.size(); i++) {
+		auto sp = springs.at(i);
+		if (!sp.isValid())
+		{
+			springs.erase(springs.begin() + i);
+			continue;
+		}
+		auto mp1 = sp.mp1.lock();
+		auto mp2 = sp.mp2.lock();
+		DUC->setUpLighting(Vec3(), 0.4 * Vec3(1, 1, 1), 100, 0.6 * Vec3(0.97, 0.86, 1));
+		
+		DUC->drawSphere(mp1->position, Vec3(0.01));
+		DUC->drawSphere(mp2->position, Vec3(0.01));
+
+		DUC->beginLine();
+		DUC->drawLine(mp1->position, Vec3(1,0,0), mp2->position, Vec3(0,1,0));
+		DUC->endLine();
+	}
+}
+
+void MassSpringSystemSimulator::notifyCaseChanged(int testCase)
+{
+	m_iTestCase = testCase;
+	system("cls");
+	reset();
+
+	switch (m_iTestCase)
+	{
+	case 0: {
+		cout << "Demo 1 !\n";
+		setMass(10);
+		setStiffness(40);
+
+		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;
+	}
+	
+	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:
+		break;
+	}
+}
+
+void MassSpringSystemSimulator::externalForcesCalculations(float timeElapsed) 
+{
+	Point2D mouseDiff;
+	mouseDiff.x = m_trackmouse.x - m_oldtrackmouse.x;
+	mouseDiff.y = m_trackmouse.y - m_oldtrackmouse.y;
+	if (mouseDiff.x != 0 || mouseDiff.y != 0)
+	{
+		Mat4 worldViewInv = Mat4(DUC->g_camera.GetWorldMatrix() * DUC->g_camera.GetViewMatrix());
+		worldViewInv = worldViewInv.inverse();
+		Vec3 inputView = Vec3((float)mouseDiff.x, (float)-mouseDiff.y, 0);
+		Vec3 inputWorld = worldViewInv.transformVectorNormal(inputView);
+		// find a proper scale!
+		float inputScale = 0.001f;
+		inputWorld = inputWorld * inputScale;
+		
+		//m_vfMovableObjectPos = m_vfMovableObjectFinalPos + inputWorld;
+	}
+	else {
+		//m_vfMovableObjectFinalPos = m_vfMovableObjectPos;
+	}
+
+}
+
+void MassSpringSystemSimulator::simulateTimestep(float timeStep)
+{
+	//update current setup for each frame
+	for (size_t i = 0; i < springs.size(); i++) {
+		auto sp = springs.at(i);
+		if (!sp.isValid())
+		{
+			springs.erase(springs.begin() + i);
+			continue;
+		}
+
+		if (m_iIntegrator == EULER) {
+
+			Euler(sp, timeStep);
+		}
+		else if (m_iIntegrator == MIDPOINT) {
+			Midpoint(sp, timeStep);
+		}
+		else if (m_iIntegrator == LEAPFROG) {
+			//TODO: Add Leapfrog
+		}
+
+	}
+}
+
+void MassSpringSystemSimulator::onClick(int x, int y)
+{
+	m_trackmouse.x = x;
+	m_trackmouse.y = y;
+}
+
+void MassSpringSystemSimulator::onMouse(int x, int y)
+{
+	m_oldtrackmouse.x = x;
+	m_oldtrackmouse.y = y;
+	m_trackmouse.x = x;
+	m_trackmouse.y = y;
+}
+
+void MassSpringSystemSimulator::setMass(float mass)
+{
+	m_fMass = mass;
+}
+
+void MassSpringSystemSimulator::setStiffness(float stiffness)
+{
+	m_fStiffness = stiffness;
+}
+
+void MassSpringSystemSimulator::setDampingFactor(float damping)
+{
+	m_fDamping = damping;
+}
+
+int MassSpringSystemSimulator::addMassPoint(Vec3 position, Vec3 Velocity, bool isFixed)
+{
+	MassPoint masspoint;
+	masspoint.position = position;
+	masspoint.velocity = Velocity;
+	masspoint.isFixed = isFixed;
+	masspoints.push_back(std::make_shared<MassPoint>(masspoint));
+
+	return masspoints.size() - 1;
+}
+
+void MassSpringSystemSimulator::addSpring(int masspoint1, int masspoint2, float initialLength)
+{
+	auto mp1 = masspoints.at(masspoint1);
+	auto mp2 = masspoints.at(masspoint2);
+
+	Spring spring;
+	spring.mp1 = mp1;
+	spring.mp2 = mp2;
+	spring.initialLength = initialLength;
+
+	springs.push_back(spring);
+}
+
+int MassSpringSystemSimulator::getNumberOfMassPoints()
+{
+	return masspoints.size();
+}
+
+int MassSpringSystemSimulator::getNumberOfSprings()
+{
+	return springs.size();
+}
+
+Vec3 MassSpringSystemSimulator::getPositionOfMassPoint(int index)
+{
+	auto mp = masspoints.at(index);
+	return mp->position;
+}
+
+Vec3 MassSpringSystemSimulator::getVelocityOfMassPoint(int index)
+{
+	auto mp = masspoints.at(index);
+	return mp->velocity;
+}
+
+void MassSpringSystemSimulator::applyExternalForce(Vec3 force)
+{
+	//eine Vorstellung: for all Masspoints, update force
+}
+
+int MassSpringSystemSimulator::LengthCalculator(Vec3 position1, Vec3 position2) {
+
+	Vec3 PosVector = position1 - position2;
+	//wurzel aus Vektor
+	int length = sqrt(pow(PosVector.x, 2) + pow(PosVector.y, 2) + pow(PosVector.z, 2));
+	
+	return length;
+}
+
+
+
+Vec3 MassSpringSystemSimulator::calculatePositionTimestepEuler(Vec3 oldPosition, float timestep, Vec3 velocity)
+{
+	return oldPosition + timestep * velocity;
+}
+
+Vec3 MassSpringSystemSimulator::calculateVelocityTimestepEuler(Vec3 oldVelocity, float timestep, Vec3 acceleration)
+{
+	return oldVelocity + acceleration * timestep;
+}
+
+Vec3 MassSpringSystemSimulator::calculateAcceleration(Vec3 force, float mass)
+{
+	return force / mass;
+}
+
+void MassSpringSystemSimulator::Midpoint(Spring& spring, float timestep) {
+	//here some implementation about Midpoint
+	auto massPoint1 = spring.mp1.lock();
+	auto massPoint2 = spring.mp2.lock();
+
+	//old position
+	auto mp = massPoint1->position;
+	auto mp2 = massPoint2->position;
+	//old Velocity
+	auto mOld_v = massPoint1->velocity;
+	auto m2Old_v = massPoint2->velocity;
+
+	Vec3 PosVector = mp - mp2;
+	//Abstand ausrechnen
+	int d = LengthCalculator(mp, mp2);
+	//normalize
+	Vec3 PosNorm1 = PosVector / d;
+	Vec3 PosNorm2 = -1 * PosNorm1;
+
+	Vec3 Force = -m_fStiffness * (d - spring.initialLength) * PosNorm1;
+	Vec3 Force2 = -1 * Force;
+
+	Vec3 oldAcc = calculateAcceleration(Force,m_fMass);
+	Vec3 oldAcc2 = calculateAcceleration(Force2, m_fMass);
+
+	//Midpoint calculator
+	//Pos of Midstep
+	Vec3 PosOfMidstep = mp + 0.5 * timestep * mOld_v;
+	Vec3 PosOfMidstep2 = mp2 + 0.5 * timestep * m2Old_v;
+	//Vel at Midstep
+	Vec3 VelAtMidstep = mOld_v + 0.5 * timestep * oldAcc;
+	Vec3 VelAtMidstep2 = m2Old_v + 0.5 * timestep * oldAcc2;
+	
+	Vec3 NewPos = mp + timestep * VelAtMidstep;
+	Vec3 NewPos2 = mp2 + timestep * VelAtMidstep2;
+
+	Vec3 NewVel = mOld_v + timestep * oldAcc;
+	Vec3 NewVel2 = m2Old_v + timestep * oldAcc2;
+	//cout << NewPos;
+	//cout << NewVel;
+	massPoint1->position = NewPos;
+	massPoint1->velocity = NewVel;
+	massPoint2->position = NewPos2;
+	massPoint2->velocity = NewVel2;
+}
+
+void MassSpringSystemSimulator::Euler(Spring& spring, float timestep)
+{
+	auto massPoint1 = spring.mp1.lock();
+	auto massPoint2 = spring.mp2.lock();
+
+	//take old position and send to calculatePositionTimestepEuler
+	auto PosVector = massPoint1->position - massPoint2->position;
+	auto lengthVector = sqrt(PosVector.x * PosVector.x + PosVector.y * PosVector.y + PosVector.z * PosVector.z);
+	auto normalized = PosVector / lengthVector;
+
+	// Actual Calculation
+	// Force of spring is -k * (l - L) * normalizedVector [for P2 we can take -F1)
+	auto force = -m_fStiffness * (lengthVector - spring.initialLength) * normalized;
+	auto foreP2 = -1 * force;
+	auto veloc = calculatePositionTimestepEuler(massPoint1->velocity, timestep, calculateAcceleration(force, 10.));
+	auto pos = calculatePositionTimestepEuler(massPoint1->position, timestep, veloc);
+
+	auto veloc2 = calculateVelocityTimestepEuler(massPoint2->velocity, timestep, calculateAcceleration(foreP2, 10.));
+	auto pos2 = calculatePositionTimestepEuler(massPoint2->position, timestep, veloc2);
+
+	// Update Positions and Velocity
+	massPoint1->position = pos;
+	massPoint1->velocity = veloc;
+
+	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());
+}

Simulations/MassSpringSystemSimulator.h

@@ -1,58 +1,74 @@
-#ifndef MASSSPRINGSYSTEMSIMULATOR_h
+#ifndef MASSSPRINGSYSTEMSIMULATOR_h
-#define MASSSPRINGSYSTEMSIMULATOR_h
+#define MASSSPRINGSYSTEMSIMULATOR_h
-#include "Simulator.h"
+#include "Simulator.h"
-
+#include "MassPoint.h"
-// Do Not Change
+#include "Spring.h"
-#define EULER 0
+
-#define LEAPFROG 1
+// Do Not Change
-#define MIDPOINT 2
+#define EULER 0
-// Do Not Change
+#define LEAPFROG 1
-
+#define MIDPOINT 2
-
+// Do Not Change
-class MassSpringSystemSimulator:public Simulator{
+
-public:
+
-	// Construtors
+class MassSpringSystemSimulator:public Simulator{
-	MassSpringSystemSimulator();
+public:
-	
+	// Construtors
-	// UI Functions
+	MassSpringSystemSimulator();
-	const char * getTestCasesStr();
+	
-	void initUI(DrawingUtilitiesClass * DUC);
+	// UI Functions
-	void reset();
+	const char * getTestCasesStr();
-	void drawFrame(ID3D11DeviceContext* pd3dImmediateContext);
+	void initUI(DrawingUtilitiesClass * DUC);
-	void notifyCaseChanged(int testCase);
+	void reset();
-	void externalForcesCalculations(float timeElapsed);
+	void drawFrame(ID3D11DeviceContext* pd3dImmediateContext);
-	void simulateTimestep(float timeStep);
+	void notifyCaseChanged(int testCase);
-	void onClick(int x, int y);
+	void externalForcesCalculations(float timeElapsed);
-	void onMouse(int x, int y);
+	void simulateTimestep(float timeStep);
-
+	void onClick(int x, int y);
-	// Specific Functions
+	void onMouse(int x, int y);
-	void setMass(float mass);
+
-	void setStiffness(float stiffness);
+	// Specific Functions
-	void setDampingFactor(float damping);
+	void setMass(float mass);
-	int addMassPoint(Vec3 position, Vec3 Velocity, bool isFixed);
+	void setStiffness(float stiffness);
-	void addSpring(int masspoint1, int masspoint2, float initialLength);
+	void setDampingFactor(float damping);
-	int getNumberOfMassPoints();
+	int addMassPoint(Vec3 position, Vec3 Velocity, bool isFixed);
-	int getNumberOfSprings();
+	void addSpring(int masspoint1, int masspoint2, float initialLength);
-	Vec3 getPositionOfMassPoint(int index);
+	int getNumberOfMassPoints();
-	Vec3 getVelocityOfMassPoint(int index);
+	int getNumberOfSprings();
+	Vec3 getPositionOfMassPoint(int index);
+	Vec3 getVelocityOfMassPoint(int index);
 	void applyExternalForce(Vec3 force);
+
+	void Midpoint(Spring& spring, float timestep);
+	int LengthCalculator(Vec3 position1, Vec3 position2);
+
+	Vec3 calculatePositionTimestepEuler(Vec3 oldPosition, float timestep, Vec3 veloctiy);
+	Vec3 calculateVelocityTimestepEuler(Vec3 oldVelocity, float timestep, Vec3 acceleration);
+	Vec3 calculateAcceleration(Vec3 acceleration, float mass);
+	void Euler(Spring& spring, float timestep);
+
+	void printSpring(const Spring& spring);
 	
 	// Do Not Change
 	void setIntegrator(int integrator) {
 		m_iIntegrator = integrator;
-	}
+	}
-
+
-private:
+private:
-	// Data Attributes
+	// Data Attributes
 	float m_fMass;
 	float m_fStiffness;
 	float m_fDamping;
-	int m_iIntegrator;
+	int m_iIntegrator;
-
+
-	// UI Attributes
+	// UI Attributes
-	Vec3 m_externalForce;
+	Vec3 m_externalForce;
-	Point2D m_mouse;
+	Point2D m_mouse;
-	Point2D m_trackmouse;
+	Point2D m_trackmouse;
-	Point2D m_oldtrackmouse;
+	Point2D m_oldtrackmouse;
-};
+
+	//Mass points and springs
+	std::vector<std::shared_ptr<MassPoint>> masspoints;
+	std::vector<Spring> springs;
+};
 #endif

Simulations/Spring.h

@@ -0,0 +1,11 @@
+#pragma once
+
+struct Spring
+{
+	std::weak_ptr<MassPoint> mp1;
+	std::weak_ptr<MassPoint> mp2;
+	float initialLength;
+	
+	bool isValid() { return !mp1.expired() && !mp2.expired(); }
+};
+

Simulations/main.cpp

@@ -20,8 +20,8 @@ using namespace GamePhysics;
 
 //#define ADAPTIVESTEP
 
-#define TEMPLATE_DEMO
+//#define TEMPLATE_DEMO
-//#define MASS_SPRING_SYSTEM
+#define MASS_SPRING_SYSTEM
 //#define RIGID_BODY_SYSTEM
 //#define SPH_SYSTEM
 
@@ -53,9 +53,14 @@ bool firstTime = true;
 FFmpeg* g_pFFmpegVideoRecorder = nullptr;
 
 
+// Input Stuff
+float lastX;
+float lastY;
+
+
 void initTweakBar(){
 	g_pDUC->g_pTweakBar = TwNewBar("TweakBar");
-	TwDefine(" TweakBar color='0 128 128' alpha=128 ");
+	TwDefine(" TweakBar color='128 128 128' alpha=128 ");
 	TwType TW_TYPE_TESTCASE = TwDefineEnumFromString("Test Scene", g_pSimulator->getTestCasesStr());
 	TwAddVarRW(g_pDUC->g_pTweakBar, "Test Scene", TW_TYPE_TESTCASE, &g_iTestCase, "");
 	// HINT: For buttons you can directly pass the callback function as a lambda expression.
@@ -202,10 +207,23 @@ void CALLBACK OnMouse( bool bLeftButtonDown, bool bRightButtonDown, bool bMiddle
 	if (bLeftButtonDown)
 	{
 		g_pSimulator->onClick(xPos,yPos);
+		
+		int x = xPos;
+		int y = yPos;
 	}
 	else
 	{
 		g_pSimulator->onMouse(xPos, yPos);
+
+		float deltaX = lastX - xPos;
+		float deltaY = lastY - yPos;
+
+		lastX = xPos;
+		lastY = yPos;
+
+		/*printf("X Delta: %f \n", deltaX);
+		printf("Y Delta: %f \n", deltaY);*/
+
 	}
 }
 

SimulatorTester/SimulatorTester_2022.vcxproj

@@ -172,9 +172,6 @@
     <ProjectReference Include="..\DirectXTK\DirectXTK_Desktop_2022.vcxproj">
       <Project>{e0b52ae7-e160-4d32-bf3f-910b785e5a8e}</Project>
     </ProjectReference>
-    <ProjectReference Include="..\DirectXTK\MakeSpriteFont\MakeSpriteFont.csproj">
-      <Project>{7329b02d-c504-482a-a156-181d48ce493c}</Project>
-    </ProjectReference>
     <ProjectReference Include="..\DXUT11\Core\DXUT_DirectXTK_2022.vcxproj">
       <Project>{85344b7f-5aa0-4e12-a065-d1333d11f6ca}</Project>
     </ProjectReference>

Template_2022.sln

@@ -13,8 +13,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DXUT", "DXUT11\Core\DXUT_Di
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DXUTOpt", "DXUT11\Optional\DXUTOpt_DirectXTK_2022.vcxproj", "{61B333C2-C4F7-4CC1-A9BF-83F6D95588EB}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MakeSpriteFont22", "DirectXTK\MakeSpriteFont\MakeSpriteFont22.csproj", "{7329B02D-C504-482A-A156-181D48CE493C}"
-EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "AntTweakBar", "AntTweakBar\src\AntTweakBar_2022.vcxproj", "{B99E1FA1-C30A-45F2-9D57-9E9C21B2DF42}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DirectXTK_Desktop_2022", "DirectXTK\DirectXTK_Desktop_2022.vcxproj", "{E0B52AE7-E160-4D32-BF3F-910B785E5A8E}"
@@ -29,6 +27,22 @@ Global
 		Release|x64 = Release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Debug|Win32.ActiveCfg = Debug|Win32
+		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Debug|Win32.Build.0 = Debug|Win32
+		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Debug|x64.ActiveCfg = Debug|x64
+		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Debug|x64.Build.0 = Debug|x64
+		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Release|Win32.ActiveCfg = Release|Win32
+		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Release|Win32.Build.0 = Release|Win32
+		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Release|x64.ActiveCfg = Release|x64
+		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Release|x64.Build.0 = Release|x64
+		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Debug|Win32.ActiveCfg = Debug|Win32
+		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Debug|Win32.Build.0 = Debug|Win32
+		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Debug|x64.ActiveCfg = Debug|x64
+		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Debug|x64.Build.0 = Debug|x64
+		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Release|Win32.ActiveCfg = Release|Win32
+		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Release|Win32.Build.0 = Release|Win32
+		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Release|x64.ActiveCfg = Release|x64
+		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Release|x64.Build.0 = Release|x64
 		{DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.ActiveCfg = Debug|Win32
 		{DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.Build.0 = Debug|Win32
 		{DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|x64.ActiveCfg = Debug|x64
@@ -61,22 +75,6 @@ Global
 		{B99E1FA1-C30A-45F2-9D57-9E9C21B2DF42}.Release|Win32.Build.0 = Release|Win32
 		{B99E1FA1-C30A-45F2-9D57-9E9C21B2DF42}.Release|x64.ActiveCfg = Release|x64
 		{B99E1FA1-C30A-45F2-9D57-9E9C21B2DF42}.Release|x64.Build.0 = Release|x64
-		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Debug|Win32.ActiveCfg = Debug|Win32
-		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Debug|Win32.Build.0 = Debug|Win32
-		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Debug|x64.ActiveCfg = Debug|x64
-		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Debug|x64.Build.0 = Debug|x64
-		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Release|Win32.ActiveCfg = Release|Win32
-		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Release|Win32.Build.0 = Release|Win32
-		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Release|x64.ActiveCfg = Release|x64
-		{3CABED2C-12F1-4408-AAAE-E2185A426F35}.Release|x64.Build.0 = Release|x64
-		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Debug|Win32.ActiveCfg = Debug|Win32
-		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Debug|Win32.Build.0 = Debug|Win32
-		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Debug|x64.ActiveCfg = Debug|x64
-		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Debug|x64.Build.0 = Debug|x64
-		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Release|Win32.ActiveCfg = Release|Win32
-		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Release|Win32.Build.0 = Release|Win32
-		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Release|x64.ActiveCfg = Release|x64
-		{0B7BAA5B-0753-4015-A8F3-8FA540FC8660}.Release|x64.Build.0 = Release|x64
 		{E0B52AE7-E160-4D32-BF3F-910B785E5A8E}.Debug|Win32.ActiveCfg = Debug|Win32
 		{E0B52AE7-E160-4D32-BF3F-910B785E5A8E}.Debug|Win32.Build.0 = Debug|Win32
 		{E0B52AE7-E160-4D32-BF3F-910B785E5A8E}.Debug|x64.ActiveCfg = Debug|x64