Add scaffolding for Kelvinlet implementation

Author: davepagurek

.gitignore

@@ -1,2 +1,26 @@
+# OS X Finder
 .DS_Store
+
+# Xcode per-user config
+*.mode1
+*.mode1v3
+*.mode2v3
+*.perspective
+*.perspectivev3
+*.pbxuser
+*.xcworkspace
+xcuserdata
+
+# Build products
+build/
 bin/*
+*.o
+*.LinkFileList
+*.hmap
+
+# Automatic backup files
+*~.nib/
+*.swp
+*~
+*.dat
+*.dep

DynamicKelvinlets.xcodeproj/project.pbxproj

@@ -0,0 +1,51 @@
+#include "DisplacedMesh.h"
+
+DisplacedMesh::DisplacedMesh(ofMesh mesh, Material material):
+  mesh(mesh),
+  material(material),
+  currentTime(0),
+  originalPositions(mesh.getVertices())
+{}
+
+void DisplacedMesh::update(float elapsedTime) {
+  currentTime += elapsedTime;
+  
+  // TODO remove kelvinlets with no influence
+  
+  mesh.getVertices() = originalPositions;
+  
+  // Take the superposition of offsets from all applied Kelvinlets
+  for (auto& kelvinlet: kelvinlets) {
+    vector<glm::vec3> offsets = kelvinlet.displacements(material, currentTime);
+    for (size_t i = 0; i < mesh.getNumVertices(); i++) {
+      mesh.setVertex(i, mesh.getVertex(i) + offsets[i]);
+    }
+  }
+}
+
+void DisplacedMesh::addKelvinlet(Kelvinlet kelvinlet) {
+  kelvinlets.push_back(DisplacedMesh::TimeShiftedKelvinlet{
+    .kelvinlet=kelvinlet,
+    .t0=currentTime,
+    .initialLocations=mesh.getVertices()
+  });
+}
+
+void DisplacedMesh::draw() const {
+  mesh.draw();
+}
+
+void DisplacedMesh::drawWireframe() const {
+  mesh.drawWireframe();
+}
+
+vector<glm::vec3> DisplacedMesh::TimeShiftedKelvinlet::displacements(Material material, float t) const {
+  vector<glm::vec3> result;
+  
+  // Apply displacements to every point
+  for (auto& point : initialLocations) {
+    result.push_back(kelvinlet.displacementRK4(point, material, t - t0));
+  }
+  
+  return result;
+}

DynamicKelvinlets.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "ofMain.h"
+#include "Kelvinlet.h"
+
+class DisplacedMesh {
+public:
+  DisplacedMesh(ofMesh mesh, Material material);
+  void update(float elapsedTime);
+  void addKelvinlet(Kelvinlet kelvinlet);
+  void draw() const;
+  void drawWireframe() const;
+  
+private:
+  // Because Kelvinlets measure distances from their centers to points at the time
+  // of the force's application, we need to save the location of the mesh's vertices
+  // at the time of force application.
+  struct TimeShiftedKelvinlet {
+    Kelvinlet kelvinlet;
+    float t0;
+    vector<glm::vec3> initialLocations;
+    
+    vector<glm::vec3> displacements(Material material, float t) const;
+  };
+  
+  ofMesh mesh;
+  Material material;
+  float currentTime;
+  vector<glm::vec3> originalPositions;
+  vector<TimeShiftedKelvinlet> kelvinlets;
+};

DynamicKelvinlets.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,20 @@
+#include "Kelvinlet.h"
+
+#include <algorithm>
+
+glm::vec3 Kelvinlet::displacementRK4(glm::vec3 position, Material material, float t) const {
+  glm::vec3 v0 = displacement(position, material, t);
+  glm::vec3 v1 = displacement(position + 0.5*v0, material, t);
+  glm::vec3 v2 = displacement(position + 0.5*v1, material, t);
+  glm::vec3 v3 = displacement(position + v2, material, t);
+  
+  return (v0 + v1*2 + v2*2 + v3) / 6;
+}
+
+glm::vec3 Kelvinlet::displacement(glm::vec3 position, Material material, float t) const {
+  // No influence at all if the impulse hasn't happened yet
+  if (t < 0) return {0,0,0};
+  
+  // TODO do actual calculation here
+  return {0,0,0};
+}

DynamicKelvinlets.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "ofMain.h"
+#include "Material.h"
+
+struct Kelvinlet {
+  glm::vec3 force;
+  glm::vec3 center;
+  float scale;
+  
+  glm::vec3 displacementRK4(glm::vec3 position, Material material, float t) const;
+  
+private:
+  glm::vec3 displacement(glm::vec3 position, Material material, float t) const;
+};

DynamicKelvinlets.xcodeproj/project.xcworkspace/xcuserdata/dpagurek.xcuserdatad/UserInterfaceState.xcuserstate

@@ -0,0 +1,9 @@
+#include "Material.h"
+#include "ofMain.h"
+
+// Stiffness is μ in Eq. 1
+// Compressibility is v in Eq. 1
+Material::Material(float stiffness, float compressibility):
+  beta(sqrt(stiffness)),
+  alpha(beta * sqrt(1.0 + 1.0/(1.0 - 2.0*compressibility)))
+{}

src/DisplacedMesh.cpp

@@ -0,0 +1,8 @@
+#pragma once
+
+struct Material {
+  Material(float stiffness, float compressibility);
+  
+  float beta;
+  float alpha;
+};

src/DisplacedMesh.h

@@ -5,6 +5,8 @@ constexpr unsigned int H = 20;
 
 //--------------------------------------------------------------
 void ofApp::setup() {
+  ofMesh mesh;
+  
   auto coordToIndex = [=](unsigned int x, unsigned int y) { return y * W + x; };
 
   for (unsigned int x = 0; x < W; x++) {
@@ -18,10 +20,19 @@ void ofApp::setup() {
       }
     }
   }
+  
+  displacedMesh = make_shared<DisplacedMesh>(mesh, Material(5, 0.45));
+  displacedMesh->addKelvinlet(Kelvinlet{
+    .force = {0, 2, 0},
+    .center = {W/2, H/2, 0},
+    .scale = 1
+  });
 }
 
 //--------------------------------------------------------------
-void ofApp::update() {}
+void ofApp::update() {
+  displacedMesh->update(ofGetLastFrameTime());
+}
 
 //--------------------------------------------------------------
 void ofApp::draw() {
@@ -32,7 +43,7 @@ void ofApp::draw() {
   ofPushMatrix();
   ofTranslate(WINDOW_WIDTH / 2 - scale * W / 2, WINDOW_HEIGHT / 2 - scale * H / 2);
   ofScale(scale);
-  mesh.drawWireframe();
+  displacedMesh->drawWireframe();
   ofPopMatrix();
 }
 

src/Kelvinlet.cpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "ofMain.h"
+#include "DisplacedMesh.h"
 
 constexpr unsigned int WINDOW_WIDTH = 1024;
 constexpr unsigned int WINDOW_HEIGHT = 768;
@@ -25,5 +26,5 @@ class ofApp : public ofBaseApp {
   void gotMessage(ofMessage msg);
 
 private:
-  ofMesh mesh;
+  shared_ptr<DisplacedMesh> displacedMesh;
 };