diff --git a/src/magnum_item.cpp b/src/magnum_item.cpp
index 8d348de..541d2b9 100644
--- a/src/magnum_item.cpp
+++ b/src/magnum_item.cpp
@@ -90,25 +90,51 @@ void MagnumItem::setCount(qint8 count) {
 void MagnumItem::keyPressEvent(QKeyEvent *evt) {
   switch (evt->key()) {
   case Qt::Key_L:
-//    if (m_camera->lagging() > 0.0f) {
-//      m_camera->setLagging(0.0f);
-//    } else {
-//      m_camera->setLagging(0.85f);
-//    }
+    auto camera = m_renderer->camera();
+    if (camera) {
+      if (camera->lagging() > 0.0f) {
+        camera->setLagging(0.0f);
+      } else {
+        camera->setLagging(0.85f);
+      }
+    }
     break;
   }
   evt->accept();
 }
 
 void MagnumItem::mousePressEvent(QMouseEvent *evt) {
+  if (auto camera = m_renderer->camera()) {
+    camera->initTransformation({evt->pos().x(), evt->pos().y()});
+  }
+  evt->accept();
 }
 
 void MagnumItem::mouseReleaseEvent(QMouseEvent *evt) {
+  evt->accept();
 }
 
-void MagnumItem::mouseMoveEvent(QMouseEvent *evt) {}
+void MagnumItem::mouseMoveEvent(QMouseEvent *evt) {
+  if (!evt->buttons())
+    return;
+  if (auto camera = m_renderer->camera()) {
+    if (evt->modifiers() & Qt::ShiftModifier) {
+      camera->translate({evt->pos().x(), evt->pos().y()});
+    } else {
+      camera->rotate({evt->pos().x(), evt->pos().y()});
+    }
+  }
+  evt->accept();
+}
 
-void MagnumItem::wheelEvent(QWheelEvent *evt) {}
+void MagnumItem::wheelEvent(QWheelEvent *evt) {
+  if (auto camera = m_renderer->camera()) {
+    const Float delta = evt->delta();
+    if (Math::abs(delta) < 1.0e-2f)
+      return;
+    camera->zoom(delta);
+  }
+}
 
 class CleanupJob : public QRunnable {
 public:
diff --git a/src/magnum_render.cpp b/src/magnum_render.cpp
index 40ae3d3..20deeab 100644
--- a/src/magnum_render.cpp
+++ b/src/magnum_render.cpp
@@ -20,23 +20,20 @@ MagnumRenderer::MagnumRenderer() :
   m_init(false),
   m_count(1) {}
 
-MagnumRenderer::~MagnumRenderer() {}
+MagnumRenderer::~MagnumRenderer() {
+  delete m_subjectObject;
+  delete m_subjectDrawable;
+  delete m_gridObject;
+}
 
 void MagnumRenderer::t(const float t) {
-  if (m_subjectObject != nullptr && m_subjectObject->parent()) {
-    m_subjectObject->resetTransformation();
-    m_subjectObject->translate(Vector3{0.f, 1.f, 0.f});
-    m_subjectObject->rotateY(Rad(t*Math::Constants<float>::pi()));
-  }
+  if (m_subjectDrawable)
+    m_subjectDrawable->t(t);
 }
 
 void MagnumRenderer::hue(float hue) {
-  if (m_subjectShader.id()) {
-    auto const color = Color3::fromHsv({Rad(hue), 1.f, 1.f});
-    m_subjectShader
-        .setDiffuseColor(color)
-        .setAmbientColor(Color3::fromHsv({color.hue(), 1.0f, 0.3f}));
-  }
+  if (m_subjectDrawable)
+    m_subjectDrawable->hue(hue);
 }
 
 void MagnumRenderer::count(int count) {
@@ -44,6 +41,10 @@ void MagnumRenderer::count(int count) {
     m_subjectDrawable->count(count);
 }
 
+Containers::Optional<ArcBallCamera> MagnumRenderer::camera() {
+  return m_camera;
+}
+
 void MagnumRenderer::lazyInitialize() {
   if (m_init) return;
 
@@ -71,7 +72,7 @@ void MagnumRenderer::lazyInitialize() {
     m_gridShader = Shaders::Flat3D{};
     m_gridShader.setColor(COLOR_GRID);
 
-    new GridDrawable{*m_gridObject, m_gridShader, m_grid, m_drawables};
+    m_gridDrawable = new GridDrawable{*m_gridObject, m_gridShader, m_grid, m_drawables};
   }
 
   // The Camera
@@ -150,10 +151,14 @@ void SubjectDrawable::draw(const Matrix4 &transformation,
   static const float width = 3.f;
   float x = -float(m_count)/2.f * width + width/2.f;
   for (int i = 0; i < m_count; i++) {
+    const auto color = Color3::fromHsv({Rad(m_hue+float(i)*.2f), 1.f, 1.f});
+    m_shader
+        .setDiffuseColor(color)
+        .setAmbientColor(Color3::fromHsv({color.hue(), 1.0f, 0.3f}));
     m_shader
         .setTransformationMatrix(
           transformation *
-          Matrix4::translation({x, 0.f, 0.f}))
+          Matrix4::translation({x, Math::sin(Rad(m_t*2.f+float(i))), 0.f}))
         .draw(m_mesh);
     x += width;
   }
@@ -162,3 +167,11 @@ void SubjectDrawable::draw(const Matrix4 &transformation,
 void SubjectDrawable::count(int count) {
   m_count = count;
 }
+
+void SubjectDrawable::hue(float hue) {
+  m_hue = hue;
+}
+
+void SubjectDrawable::t(float t) {
+  m_t = t;
+}
diff --git a/src/magnum_render.h b/src/magnum_render.h
index 33d8ed1..e05da78 100644
--- a/src/magnum_render.h
+++ b/src/magnum_render.h
@@ -46,11 +46,15 @@ public:
 
   void draw(const Matrix4 &transformation, SceneGraph::Camera3D &camera);
   void count(int count);
+  void hue(float hue);
+  void t(float t);
 
 private:
   Shaders::Phong &m_shader;
   GL::Mesh &m_mesh;
   int m_count;
+  float m_hue;
+  float m_t;
 };
 
 class MagnumRenderer {
@@ -68,6 +72,7 @@ public:
   void t(float t);
   void hue(float hue);
   void count(int count);
+  Containers::Optional<ArcBallCamera> camera();
 
 private:
   void lazyInitialize();
@@ -91,6 +96,7 @@ private:
   GL::Mesh m_grid{NoCreate};
   Shaders::Flat3D m_gridShader{NoCreate};
   Object3D* m_gridObject{nullptr};
+  GridDrawable* m_gridDrawable{nullptr};
 };
 
 #endif // MAGNUM_RENDER_H
diff --git a/src/qml/main.qml b/src/qml/main.qml
index 564efd7..2c8b4f8 100644
--- a/src/qml/main.qml
+++ b/src/qml/main.qml
@@ -93,8 +93,8 @@ ApplicationWindow {
             count: count.value
 
             SequentialAnimation on t {
-                NumberAnimation { to: 1; duration: 2500; easing.type: Easing.InQuad }
-                NumberAnimation { to: 0; duration: 2500; easing.type: Easing.OutQuad }
+                NumberAnimation { to: 10; duration: 10000; easing.type: Easing.InQuad }
+                NumberAnimation { to: 0; duration: 10000; easing.type: Easing.OutQuad }
                 loops: Animation.Infinite
                 running: true
             }