diff --git a/components/nif/controlled.hpp b/components/nif/controlled.hpp
index d59950132..24281146f 100644
--- a/components/nif/controlled.hpp
+++ b/components/nif/controlled.hpp
@@ -25,6 +25,7 @@
 #define _NIF_CONTROLLED_H_
 
 #include "extra.hpp"
+#include "controller.hpp"
 
 namespace Nif
 {
@@ -33,92 +34,104 @@ namespace Nif
 class Controlled : public Extra
 {
 public:
-  ControllerPtr controller;
-
-  void read(NIFFile *nif)
-  {
-    Extra::read(nif);
-    controller.read(nif);
-  }
+    ControllerPtr controller;
+
+    void read(NIFFile *nif)
+    {
+        Extra::read(nif);
+        controller.read(nif);
+    }
+
+    void post(NIFFile *nif)
+    {
+        Extra::post(nif);
+        controller.post(nif);
+    }
 };
 
 /// Has name, extra-data and controller
 class Named : public Controlled
 {
 public:
-  Misc::SString name;
+    Misc::SString name;
 
-  void read(NIFFile *nif)
-  {
-    name = nif->getString();
-    Controlled::read(nif);
-  }
+    void read(NIFFile *nif)
+    {
+        name = nif->getString();
+        Controlled::read(nif);
+    }
 };
 typedef Named NiSequenceStreamHelper;
 
 class NiParticleGrowFade : public Controlled
 {
 public:
-  void read(NIFFile *nif)
-  {
-    Controlled::read(nif);
+    void read(NIFFile *nif)
+    {
+        Controlled::read(nif);
 
-    // Two floats.
-    nif->skip(8);
-  }
+        // Two floats.
+        nif->skip(8);
+    }
 };
 
 class NiParticleColorModifier : public Controlled
 {
 public:
-  NiColorDataPtr data;
-
-  void read(NIFFile *nif)
-  {
-    Controlled::read(nif);
-    data.read(nif);
-  }
+    NiColorDataPtr data;
+
+    void read(NIFFile *nif)
+    {
+        Controlled::read(nif);
+        data.read(nif);
+    }
+
+    void post(NIFFile *nif)
+    {
+        Controlled::post(nif);
+        data.post(nif);
+    }
 };
 
 class NiGravity : public Controlled
 {
 public:
-  void read(NIFFile *nif)
-  {
-    Controlled::read(nif);
+    void read(NIFFile *nif)
+    {
+        Controlled::read(nif);
 
-    // two floats, one int, six floats
-    nif->skip(9*4);
-  }
+        // two floats, one int, six floats
+        nif->skip(9*4);
+    }
 };
 
 // NiPinaColada
 class NiPlanarCollider : public Controlled
 {
 public:
-  void read(NIFFile *nif)
-  {
-    Controlled::read(nif);
+    void read(NIFFile *nif)
+    {
+        Controlled::read(nif);
 
-    // (I think) 4 floats + 4 vectors
-    nif->skip(4*16);
-  }
+        // (I think) 4 floats + 4 vectors
+        nif->skip(4*16);
+    }
 };
 
 class NiParticleRotation : public Controlled
 {
 public:
-  void read(NIFFile *nif)
-  {
-    Controlled::read(nif);
-
-    /*
-      byte (0 or 1)
-      float (1)
-      float*3
-     */
-    nif->skip(17);
-  }
+    void read(NIFFile *nif)
+    {
+        Controlled::read(nif);
+
+        /*
+           byte (0 or 1)
+           float (1)
+           float*3
+        */
+        nif->skip(17);
+    }
 };
 
 } // Namespace
diff --git a/components/nif/controller.hpp b/components/nif/controller.hpp
index d6fb22255..d00c1bc0e 100644
--- a/components/nif/controller.hpp
+++ b/components/nif/controller.hpp
@@ -34,136 +34,187 @@ namespace Nif
 class Controller : public Record
 {
 public:
-  ControllerPtr next;
-  int flags;
-  float frequency, phase;
-  float timeStart, timeStop;
-  ControlledPtr target;
-
-  void read(NIFFile *nif)
-  {
-    next.read(nif);
-
-    flags = nif->getShort();
-
-    frequency = nif->getFloat();
-    phase = nif->getFloat();
-    timeStart = nif->getFloat();
-    timeStop = nif->getFloat();
-
-    target.read(nif);
-  }
+    ControllerPtr next;
+    int flags;
+    float frequency, phase;
+    float timeStart, timeStop;
+    ControlledPtr target;
+
+    void read(NIFFile *nif)
+    {
+        next.read(nif);
+
+        flags = nif->getShort();
+
+        frequency = nif->getFloat();
+        phase = nif->getFloat();
+        timeStart = nif->getFloat();
+        timeStop = nif->getFloat();
+
+        target.read(nif);
+    }
+
+    void post(NIFFile *nif)
+    {
+        Record::post(nif);
+        next.post(nif);
+        target.post(nif);
+    }
 };
 
 class NiBSPArrayController : public Controller
 {
 public:
-  void read(NIFFile *nif)
-  {
-    Controller::read(nif);
-
-    // At the moment, just skip it all
-    nif->skip(111);
-    int s = nif->getShort();
-    nif->skip(15 + s*40);
-  }
+    void read(NIFFile *nif)
+    {
+        Controller::read(nif);
+
+        // At the moment, just skip it all
+        nif->skip(111);
+        int s = nif->getShort();
+        nif->skip(15 + s*40);
+    }
 };
 typedef NiBSPArrayController NiParticleSystemController;
 
 class NiMaterialColorController : public Controller
 {
 public:
-  NiPosDataPtr data;
-
-  void read(NIFFile *nif)
-  {
-    Controller::read(nif);
-    data.read(nif);
-  }
+    NiPosDataPtr data;
+
+    void read(NIFFile *nif)
+    {
+        Controller::read(nif);
+        data.read(nif);
+    }
+
+    void post(NIFFile *nif)
+    {
+        Controller::post(nif);
+        data.post(nif);
+    }
 };
 
 class NiPathController : public Controller
 {
 public:
-  NiPosDataPtr posData;
-  NiFloatDataPtr floatData;
-
-  void read(NIFFile *nif)
-  {
-    Controller::read(nif);
-
-    /*
-      int = 1
-      2xfloat
-      short = 0 or 1
-     */
-    nif->skip(14);
-    posData.read(nif);
-    floatData.read(nif);
-  }
+    NiPosDataPtr posData;
+    NiFloatDataPtr floatData;
+
+    void read(NIFFile *nif)
+    {
+        Controller::read(nif);
+
+        /*
+           int = 1
+           2xfloat
+           short = 0 or 1
+        */
+        nif->skip(14);
+        posData.read(nif);
+        floatData.read(nif);
+    }
+
+    void post(NIFFile *nif)
+    {
+        Controller::post(nif);
+
+        posData.post(nif);
+        floatData.post(nif);
+    }
 };
 
 class NiUVController : public Controller
 {
 public:
-  NiUVDataPtr data;
+    NiUVDataPtr data;
 
-  void read(NIFFile *nif)
-  {
-    Controller::read(nif);
+    void read(NIFFile *nif)
+    {
+        Controller::read(nif);
 
-    nif->getShort(); // always 0
-    data.read(nif);
-  }
+        nif->getShort(); // always 0
+        data.read(nif);
+    }
+
+    void post(NIFFile *nif)
+    {
+        Controller::post(nif);
+        data.post(nif);
+    }
 };
 
 class NiKeyframeController : public Controller
 {
 public:
-  NiKeyframeDataPtr data;
-
-  void read(NIFFile *nif)
-  {
-    Controller::read(nif);
-    data.read(nif);
-  }
+    NiKeyframeDataPtr data;
+
+    void read(NIFFile *nif)
+    {
+        Controller::read(nif);
+        data.read(nif);
+    }
+
+    void post(NIFFile *nif)
+    {
+        Controller::post(nif);
+        data.post(nif);
+    }
 };
 
 class NiAlphaController : public Controller
 {
 public:
-  NiFloatDataPtr data;
-
-  void read(NIFFile *nif)
-  {
-    Controller::read(nif);
-    data.read(nif);
-  }
+    NiFloatDataPtr data;
+
+    void read(NIFFile *nif)
+    {
+        Controller::read(nif);
+        data.read(nif);
+    }
+
+    void post(NIFFile *nif)
+    {
+        Controller::post(nif);
+        data.post(nif);
+    }
 };
 
 class NiGeomMorpherController : public Controller
 {
 public:
-  NiMorphDataPtr data;
-
-  void read(NIFFile *nif)
-  {
-    Controller::read(nif);
-    data.read(nif);
-    nif->getByte(); // always 0
-  }
+    NiMorphDataPtr data;
+
+    void read(NIFFile *nif)
+    {
+        Controller::read(nif);
+        data.read(nif);
+        nif->getByte(); // always 0
+    }
+
+    void post(NIFFile *nif)
+    {
+        Controller::post(nif);
+        data.post(nif);
+    }
 };
 
 class NiVisController : public Controller
 {
 public:
-  NiVisDataPtr data;
-
-  void read(NIFFile *nif)
-  {
-    Controller::read(nif);
-    data.read(nif);
-  }
+    NiVisDataPtr data;
+
+    void read(NIFFile *nif)
+    {
+        Controller::read(nif);
+        data.read(nif);
+    }
+
+    void post(NIFFile *nif)
+    {
+        Controller::post(nif);
+        data.post(nif);
+    }
 };
 
 } // Namespace
diff --git a/components/nif/data.hpp b/components/nif/data.hpp
index df9079758..eaa11b5ee 100644
--- a/components/nif/data.hpp
+++ b/components/nif/data.hpp
@@ -34,794 +34,777 @@ namespace Nif
 class NiSourceTexture : public Named
 {
 public:
+    // Is this an external (references a separate texture file) or
+    // internal (data is inside the nif itself) texture?
+    bool external;
+
+    Misc::SString filename;    // In case of external textures
+    NiPixelDataPtr data; // In case of internal textures
+
+    /* Pixel layout
+        0 - Palettised
+        1 - High color 16
+        2 - True color 32
+        3 - Compressed
+        4 - Bumpmap
+        5 - Default */
+    int pixel;
+
+    /* Mipmap format
+        0 - no
+        1 - yes
+        2 - default */
+    int mipmap;
+
+    /* Alpha
+        0 - none
+        1 - binary
+        2 - smooth
+        3 - default (use material alpha, or multiply material with texture if present)
+    */
+    int alpha;
+
+    void read(NIFFile *nif)
+    {
+        Named::read(nif);
 
-  // Is this an external (references a separate texture file) or
-  // internal (data is inside the nif itself) texture?
-  bool external;
-
-  Misc::SString filename;    // In case of external textures
-  NiPixelDataPtr data; // In case of internal textures
-
-  /* Pixel layout
-     0 - Palettised
-     1 - High color 16
-     2 - True color 32
-     3 - Compressed
-     4 - Bumpmap
-     5 - Default */
-  int pixel;
-
-  /* Mipmap format
-     0 - no
-     1 - yes
-     2 - default */
-  int mipmap;
-
-  /* Alpha
-     0 - none
-     1 - binary
-     2 - smooth
-     3 - default (use material alpha, or multiply material with texture if present)
-  */
-  int alpha;
-
-  void read(NIFFile *nif)
-  {
-    Named::read(nif);
-
-    external = !!nif->getByte();
-
-    if(external) filename = nif->getString();
-    else
-      {
-        nif->getByte(); // always 1
-        data.read(nif);
-      }
+        external = !!nif->getByte();
+        if(external)
+            filename = nif->getString();
+        else
+        {
+            nif->getByte(); // always 1
+            data.read(nif);
+        }
 
-    pixel = nif->getInt();
-    mipmap = nif->getInt();
-    alpha = nif->getInt();
+        pixel = nif->getInt();
+        mipmap = nif->getInt();
+        alpha = nif->getInt();
 
-    nif->getByte(); // always 1
-  }
+        nif->getByte(); // always 1
+    }
+
+    void post(NIFFile *nif)
+    {
+        Named::post(nif);
+        data.post(nif);
+    }
 };
 
 // Common ancestor for several data classes
 class ShapeData : public Record
 {
 public:
-  Misc::FloatArray vertices, normals, colors, uvlist;
-  const Vector *center;
-  float radius;
+    Misc::FloatArray vertices, normals, colors, uvlist;
+    const Vector *center;
+    float radius;
 
-  void read(NIFFile *nif)
-  {
-    int verts = nif->getShort();
+    void read(NIFFile *nif)
+    {
+        int verts = nif->getShort();
 
-    if(nif->getInt())
-      vertices = nif->getFloatLen(verts*3);
+        if(nif->getInt())
+            vertices = nif->getFloatLen(verts*3);
 
-    if(nif->getInt())
-      normals = nif->getFloatLen(verts*3);
+        if(nif->getInt())
+            normals = nif->getFloatLen(verts*3);
 
-    center = nif->getVector();
-    radius = nif->getFloat();
+        center = nif->getVector();
+        radius = nif->getFloat();
 
-    if(nif->getInt())
-      colors = nif->getFloatLen(verts*4);
+        if(nif->getInt())
+            colors = nif->getFloatLen(verts*4);
 
-    int uvs = nif->getShort();
+        int uvs = nif->getShort();
 
-    // Only the first 6 bits are used as a count. I think the rest are
-    // flags of some sort.
-    uvs &= 0x3f;
+        // Only the first 6 bits are used as a count. I think the rest are
+        // flags of some sort.
+        uvs &= 0x3f;
 
-    if(nif->getInt())
-      uvlist = nif->getFloatLen(uvs*verts*2);
-  }
+        if(nif->getInt())
+            uvlist = nif->getFloatLen(uvs*verts*2);
+    }
 };
 
 class NiTriShapeData : public ShapeData
 {
 public:
-  // Triangles, three vertex indices per triangle
-  Misc::SliceArray<short> triangles;
-
-  void read(NIFFile *nif)
-  {
-    ShapeData::read(nif);
-
-    int tris = nif->getShort();
-    if(tris)
-      {
-        // We have three times as many vertices as triangles, so this
-        // is always equal to tris*3.
-        int cnt = nif->getInt();
-        triangles = nif->getArrayLen<short>(cnt);
-      }
-
-    // Read the match list, which lists the vertices that are equal to
-    // vertices. We don't actually need need this for anything, so
-    // just skip it.
-    int verts = nif->getShort();
-    if(verts)
-      {
-        for(int i=0;i<verts;i++)
-          {
-            // Number of vertices matching vertex 'i'
-            short num = nif->getShort();
-            nif->skip(num*sizeof(short));
-          }
-      }
-  }
+    // Triangles, three vertex indices per triangle
+    Misc::SliceArray<short> triangles;
+
+    void read(NIFFile *nif)
+    {
+        ShapeData::read(nif);
+
+        int tris = nif->getShort();
+        if(tris)
+        {
+            // We have three times as many vertices as triangles, so this
+            // is always equal to tris*3.
+            int cnt = nif->getInt();
+            triangles = nif->getArrayLen<short>(cnt);
+        }
+
+        // Read the match list, which lists the vertices that are equal to
+        // vertices. We don't actually need need this for anything, so
+        // just skip it.
+        int verts = nif->getShort();
+        if(verts)
+        {
+            for(int i=0;i<verts;i++)
+            {
+                // Number of vertices matching vertex 'i'
+                short num = nif->getShort();
+                nif->skip(num*sizeof(short));
+            }
+        }
+    }
 };
 
 class NiAutoNormalParticlesData : public ShapeData
 {
 public:
-  int activeCount;
+    int activeCount;
 
-  void read(NIFFile *nif)
-  {
-    ShapeData::read(nif);
+    void read(NIFFile *nif)
+    {
+        ShapeData::read(nif);
 
-    // Should always match the number of vertices
-    activeCount = nif->getShort();
+        // Should always match the number of vertices
+        activeCount = nif->getShort();
 
-    // Skip all the info, we don't support particles yet
-    nif->getFloat();  // Active radius ?
-    nif->getShort(); // Number of valid entries in the following arrays ?
+        // Skip all the info, we don't support particles yet
+        nif->getFloat();  // Active radius ?
+        nif->getShort(); // Number of valid entries in the following arrays ?
 
-    if(nif->getInt())
-      // Particle sizes
-      nif->getFloatLen(activeCount);
-  }
+        if(nif->getInt())
+        {
+            // Particle sizes
+            nif->getFloatLen(activeCount);
+        }
+    }
 };
 
 class NiRotatingParticlesData : public NiAutoNormalParticlesData
 {
 public:
-  void read(NIFFile *nif)
-  {
-    NiAutoNormalParticlesData::read(nif);
-
-    if(nif->getInt())
-      // Rotation quaternions. I THINK activeCount is correct here,
-      // but verts (vertex number) might also be correct, if there is
-      // any case where the two don't match.
-      nif->getArrayLen<Vector4>(activeCount);
-  }
+    void read(NIFFile *nif)
+    {
+        NiAutoNormalParticlesData::read(nif);
+
+        if(nif->getInt())
+        {
+            // Rotation quaternions. I THINK activeCount is correct here,
+            // but verts (vertex number) might also be correct, if there is
+            // any case where the two don't match.
+            nif->getArrayLen<Vector4>(activeCount);
+        }
+    }
 };
 
 class NiPosData : public Record
 {
 public:
-  void read(NIFFile *nif)
-  {
-    int count = nif->getInt();
-    int type = nif->getInt();
-    if(type != 1 && type != 2)
-      nif->fail("Cannot handle NiPosData type");
-
-    // TODO: Could make structs of these. Seems to be identical to
-    // translation in NiKeyframeData.
-    for(int i=0; i<count; i++)
-      {
-        /*float time =*/ nif->getFloat();
-        nif->getVector(); // This isn't really shared between type 1
-                          // and type 2, most likely
-        if(type == 2)
-          {
-            nif->getVector();
-            nif->getVector();
-          }
-      }
-  }
+    void read(NIFFile *nif)
+    {
+        int count = nif->getInt();
+        int type = nif->getInt();
+        if(type != 1 && type != 2)
+            nif->fail("Cannot handle NiPosData type");
+
+        // TODO: Could make structs of these. Seems to be identical to
+        // translation in NiKeyframeData.
+        for(int i=0; i<count; i++)
+        {
+            /*float time =*/ nif->getFloat();
+            nif->getVector(); // This isn't really shared between type 1
+                              // and type 2, most likely
+            if(type == 2)
+            {
+                nif->getVector();
+                nif->getVector();
+            }
+        }
+    }
 };
 
 class NiUVData : public Record
 {
 public:
-  void read(NIFFile *nif)
-  {
-    // TODO: This is claimed to be a "float animation key", which is
-    // also used in FloatData and KeyframeData. We could probably
-    // reuse and refactor a lot of this if we actually use it at some
-    // point.
-
-    for(int i=0; i<2; i++)
-      {
-        int count = nif->getInt();
-
-        if(count)
-          {
-            nif->getInt(); // always 2
-            nif->getArrayLen<Vector4>(count); // Really one time float + one vector
-          }
-      }
-    // Always 0
-    nif->getInt();
-    nif->getInt();
-  }
+    void read(NIFFile *nif)
+    {
+        // TODO: This is claimed to be a "float animation key", which is
+        // also used in FloatData and KeyframeData. We could probably
+        // reuse and refactor a lot of this if we actually use it at some
+        // point.
+        for(int i=0; i<2; i++)
+        {
+            int count = nif->getInt();
+            if(count)
+            {
+                nif->getInt(); // always 2
+                nif->getArrayLen<Vector4>(count); // Really one time float + one vector
+            }
+        }
+        // Always 0
+        nif->getInt();
+        nif->getInt();
+    }
 };
 
 class NiFloatData : public Record
 {
 public:
-  void read(NIFFile *nif)
-  {
-    int count = nif->getInt();
-    nif->getInt(); // always 2
-    nif->getArrayLen<Vector4>(count); // Really one time float + one vector
-  }
+    void read(NIFFile *nif)
+    {
+        int count = nif->getInt();
+        nif->getInt(); // always 2
+        nif->getArrayLen<Vector4>(count); // Really one time float + one vector
+    }
 };
 
 class NiPixelData : public Record
 {
 public:
-  unsigned int rmask, gmask, bmask, amask;
-  int bpp, mips;
+    unsigned int rmask, gmask, bmask, amask;
+    int bpp, mips;
 
-  void read(NIFFile *nif)
-  {
-    nif->getInt(); // always 0 or 1
+    void read(NIFFile *nif)
+    {
+        nif->getInt(); // always 0 or 1
 
-    rmask = nif->getInt(); // usually 0xff
-    gmask = nif->getInt(); // usually 0xff00
-    bmask = nif->getInt(); // usually 0xff0000
-    amask = nif->getInt(); // usually 0xff000000 or zero
+        rmask = nif->getInt(); // usually 0xff
+        gmask = nif->getInt(); // usually 0xff00
+        bmask = nif->getInt(); // usually 0xff0000
+        amask = nif->getInt(); // usually 0xff000000 or zero
 
-    bpp = nif->getInt();
+        bpp = nif->getInt();
 
-    // Unknown
-    nif->skip(12);
+        // Unknown
+        nif->skip(12);
 
-    mips = nif->getInt();
+        mips = nif->getInt();
 
-    // Bytes per pixel, should be bpp * 8
-    /*int bytes =*/ nif->getInt();
+        // Bytes per pixel, should be bpp * 8
+        /*int bytes =*/ nif->getInt();
 
-    for(int i=0; i<mips; i++)
-      {
-        // Image size and offset in the following data field
-        /*int x =*/ nif->getInt();
-        /*int y =*/ nif->getInt();
-        /*int offset =*/ nif->getInt();
-      }
+        for(int i=0; i<mips; i++)
+        {
+            // Image size and offset in the following data field
+            /*int x =*/ nif->getInt();
+            /*int y =*/ nif->getInt();
+            /*int offset =*/ nif->getInt();
+        }
 
-    // Skip the data
-    unsigned int dataSize = nif->getInt();
-    nif->skip(dataSize);
-  }
+        // Skip the data
+        unsigned int dataSize = nif->getInt();
+        nif->skip(dataSize);
+    }
 };
 
 class NiColorData : public Record
 {
 public:
-  struct ColorData
-  {
-    float time;
-    Vector4 rgba;
-  };
-
-  void read(NIFFile *nif)
-  {
-    int count = nif->getInt();
-    nif->getInt(); // always 1
-
-    // Skip the data
-    assert(sizeof(ColorData) == 4*5);
-    nif->skip(sizeof(ColorData) * count);
-  }
+    struct ColorData
+    {
+        float time;
+        Vector4 rgba;
+    };
+
+    void read(NIFFile *nif)
+    {
+        int count = nif->getInt();
+        nif->getInt(); // always 1
+
+        // Skip the data
+        assert(sizeof(ColorData) == 4*5);
+        nif->skip(sizeof(ColorData) * count);
+    }
 };
 
 class NiVisData : public Record
 {
 public:
-  void read(NIFFile *nif)
-  {
-    int count = nif->getInt();
-    /*
-      Each VisData consists of:
-        float time;
-        byte isSet;
-
-      If you implement this, make sure you use a packed struct
-      (sizeof==5), or read each element individually.
-     */
-    nif->skip(count*5);
-  }
+    void read(NIFFile *nif)
+    {
+        int count = nif->getInt();
+        /*
+           Each VisData consists of:
+            float time;
+            byte isSet;
+
+           If you implement this, make sure you use a packed struct
+           (sizeof==5), or read each element individually.
+        */
+        nif->skip(count*5);
+    }
 };
 
 class NiSkinInstance : public Record
 {
 public:
-  NiSkinDataPtr data;
-  NodePtr root;
-  NodeList bones;
-
-  void read(NIFFile *nif)
-  {
-    data.read(nif);
-    root.read(nif);
-    bones.read(nif);
+    NiSkinDataPtr data;
+    NodePtr root;
+    NodeList bones;
 
-    if(data.empty() || root.empty())
-      nif->fail("NiSkinInstance missing root or data");
-  }
+    void read(NIFFile *nif)
+    {
+        data.read(nif);
+        root.read(nif);
+        bones.read(nif);
+    }
 
-  void post(NIFFile *nif);
+    void post(NIFFile *nif);
 };
 
 class NiSkinData : public Record
 {
 public:
-  // This is to make sure the structs are packed, ie. that the
-  // compiler doesn't mess them up with extra alignment bytes.
+    // This is to make sure the structs are packed, ie. that the
+    // compiler doesn't mess them up with extra alignment bytes.
 #pragma pack(push)
 #pragma pack(1)
 
-  struct BoneTrafo
-  {
-    Matrix rotation; // Rotation offset from bone?
-    Vector trans;    // Translation
-    float scale;     // Probably scale (always 1)
-  };
-  struct BoneTrafoCopy
-  {
-	  Ogre::Quaternion rotation;
-	  Ogre::Vector3 trans;
-	  float scale;
-  };
-
-  struct VertWeight
-  {
-    short vertex;
-    float weight;
-  };
+    struct BoneTrafo
+    {
+        Matrix rotation; // Rotation offset from bone?
+        Vector trans;    // Translation
+        float scale;     // Probably scale (always 1)
+    };
+    struct BoneTrafoCopy
+    {
+        Ogre::Quaternion rotation;
+        Ogre::Vector3 trans;
+        float scale;
+    };
+
+    struct VertWeight
+    {
+        short vertex;
+        float weight;
+    };
 #pragma pack(pop)
 
-  struct BoneInfo
-  {
-    const BoneTrafo *trafo;
-    const Vector4 *unknown;
-    Misc::SliceArray<VertWeight> weights;
-  };
-  struct BoneInfoCopy
-  {
-	   std::string bonename;
-       unsigned short bonehandle;
-	   BoneTrafoCopy trafo;
-	   Vector4 unknown;
-       //std::vector<VertWeight> weights;
-  };
-  struct IndividualWeight
-  {
-      float weight;
+    struct BoneInfo
+    {
+        const BoneTrafo *trafo;
+        const Vector4 *unknown;
+        Misc::SliceArray<VertWeight> weights;
+    };
+    struct BoneInfoCopy
+    {
+        std::string bonename;
+        unsigned short bonehandle;
+        BoneTrafoCopy trafo;
+        Vector4 unknown;
+        //std::vector<VertWeight> weights;
+    };
+    struct IndividualWeight
+    {
+        float weight;
         unsigned int boneinfocopyindex;
-  };
-
-  const BoneTrafo *trafo;
-  std::vector<BoneInfo> bones;
+    };
 
-  void read(NIFFile *nif)
-  {
-    assert(sizeof(BoneTrafo) == 4*(9+3+1));
-    assert(sizeof(VertWeight) == 6);
+    const BoneTrafo *trafo;
+    std::vector<BoneInfo> bones;
 
-    trafo = nif->getPtr<BoneTrafo>();
+    void read(NIFFile *nif)
+    {
+        assert(sizeof(BoneTrafo) == 4*(9+3+1));
+        assert(sizeof(VertWeight) == 6);
 
-    int boneNum = nif->getInt();
-    nif->getInt(); // -1
+        trafo = nif->getPtr<BoneTrafo>();
 
-    bones.resize(boneNum);
+        int boneNum = nif->getInt();
+        nif->getInt(); // -1
 
-    for(int i=0;i<boneNum;i++)
-      {
-        BoneInfo &bi = bones[i];
+        bones.resize(boneNum);
+        for(int i=0;i<boneNum;i++)
+        {
+            BoneInfo &bi = bones[i];
 
-        bi.trafo = nif->getPtr<BoneTrafo>();
-        bi.unknown = nif->getVector4();
+            bi.trafo = nif->getPtr<BoneTrafo>();
+            bi.unknown = nif->getVector4();
 
-        // Number of vertex weights
-        int count = nif->getShort();
-        bi.weights = nif->getArrayLen<VertWeight>(count);
-      }
-  }
+            // Number of vertex weights
+            int count = nif->getShort();
+            bi.weights = nif->getArrayLen<VertWeight>(count);
+        }
+    }
 };
 
 class NiMorphData : public Record
 {
-	float startTime;
-	float stopTime;
-	std::vector<Ogre::Vector3> initialVertices;
-	std::vector<std::vector<float> > relevantTimes;
-	std::vector<std::vector<Ogre::Vector3> > relevantData;
-	std::vector<std::vector<Ogre::Vector3> > additionalVertices;
-
+    float startTime;
+    float stopTime;
+    std::vector<Ogre::Vector3> initialVertices;
+    std::vector<std::vector<float> > relevantTimes;
+    std::vector<std::vector<Ogre::Vector3> > relevantData;
+    std::vector<std::vector<Ogre::Vector3> > additionalVertices;
 
 public:
-	  float getStartTime(){
-	     return startTime;
-	  }
-	  float getStopTime(){
-	      return stopTime;
-	  }
-	  void setStartTime(float time){
-			startTime = time;
-	  }
-
-	  void setStopTime(float time){
-			stopTime = time;
-	  }
-	  std::vector<Ogre::Vector3> getInitialVertices(){
-			return initialVertices;
-	  }
-	  std::vector<std::vector<Ogre::Vector3> > getRelevantData(){
-			return relevantData;
-	  }
-	  std::vector<std::vector<float> > getRelevantTimes(){
-			return relevantTimes;
-	  }
-	   std::vector<std::vector<Ogre::Vector3> > getAdditionalVertices(){
-			return additionalVertices;
-	  }
-	  
-void read(NIFFile *nif)
-  {
-    int morphCount = nif->getInt();
-    int vertCount  = nif->getInt();
-    nif->getByte();
-	int magic = nif->getInt();
-	/*int type =*/ nif->getInt();
-	for(int i = 0; i < vertCount; i++){
-
-		float x = nif->getFloat();
-		float y = nif->getFloat();
-		float z = nif->getFloat();
-		initialVertices.push_back(Ogre::Vector3(x, y, z));
-	}
-	
-    for(int i=1; i<morphCount; i++)
+    float getStartTime() const
+    { return startTime; }
+    float getStopTime() const
+    { return stopTime; }
+
+    void setStartTime(float time)
+    { startTime = time; }
+    void setStopTime(float time)
+    { stopTime = time; }
+
+    const std::vector<Ogre::Vector3>& getInitialVertices() const
+    { return initialVertices; }
+    const std::vector<std::vector<Ogre::Vector3> >& getRelevantData() const
+    { return relevantData; }
+    const std::vector<std::vector<float> >& getRelevantTimes() const
+    { return relevantTimes; }
+    const std::vector<std::vector<Ogre::Vector3> >& getAdditionalVertices() const
+    { return additionalVertices; }
+
+    void read(NIFFile *nif)
     {
-        magic = nif->getInt();
-        /*type =*/ nif->getInt();
-		std::vector<Ogre::Vector3> current;
-		std::vector<float> currentTime;
-        for(int i = 0; i < magic; i++){
-        // Time, data, forward, backward tangents
-	        float time = nif->getFloat();
-		    float x = nif->getFloat();
-		    float y = nif->getFloat();
-		    float z = nif->getFloat();
-		    current.push_back(Ogre::Vector3(x,y,z));
-		    currentTime.push_back(time);
-          //nif->getFloatLen(4*magic);
-		}
-		if(magic){
-			relevantData.push_back(current);
-			relevantTimes.push_back(currentTime);
-		}
-		std::vector<Ogre::Vector3> verts;
-        for(int i = 0; i < vertCount; i++){
-		    float x = nif->getFloat();
-		    float y = nif->getFloat();
-		    float z = nif->getFloat();
-		    verts.push_back(Ogre::Vector3(x, y, z));
-		}
-		additionalVertices.push_back(verts);
-      }
-  }
+        int morphCount = nif->getInt();
+        int vertCount  = nif->getInt();
+        nif->getByte();
+        int magic = nif->getInt();
+        /*int type =*/ nif->getInt();
+
+        for(int i = 0; i < vertCount; i++)
+        {
+            float x = nif->getFloat();
+            float y = nif->getFloat();
+            float z = nif->getFloat();
+            initialVertices.push_back(Ogre::Vector3(x, y, z));
+        }
+
+        for(int i=1; i<morphCount; i++)
+        {
+            magic = nif->getInt();
+            /*type =*/ nif->getInt();
+            std::vector<Ogre::Vector3> current;
+            std::vector<float> currentTime;
+            for(int i = 0; i < magic; i++)
+            {
+                // Time, data, forward, backward tangents
+                float time = nif->getFloat();
+                float x = nif->getFloat();
+                float y = nif->getFloat();
+                float z = nif->getFloat();
+                current.push_back(Ogre::Vector3(x,y,z));
+                currentTime.push_back(time);
+                //nif->getFloatLen(4*magic);
+            }
+
+            if(magic)
+            {
+                relevantData.push_back(current);
+                relevantTimes.push_back(currentTime);
+            }
+
+            std::vector<Ogre::Vector3> verts;
+            for(int i = 0; i < vertCount; i++)
+            {
+                float x = nif->getFloat();
+                float y = nif->getFloat();
+                float z = nif->getFloat();
+                verts.push_back(Ogre::Vector3(x, y, z));
+            }
+            additionalVertices.push_back(verts);
+        }
+    }
 };
 
 
 class NiKeyframeData : public Record
 {
-	std::string bonename;
-	//Rotations
-	std::vector<Ogre::Quaternion> quats;
-	std::vector<Ogre::Vector3> tbc;
-	std::vector<float> rottime;
-	float startTime;
-	float stopTime;
-	int rtype;
-
-	//Translations
-	std::vector<Ogre::Vector3> translist1;
-	std::vector<Ogre::Vector3> translist2;
-	std::vector<Ogre::Vector3> translist3;
-	std::vector<Ogre::Vector3> transtbc;
-	std::vector<float> transtime;
-	int ttype;
-
-	//Scalings
-
-	std::vector<float> scalefactor;
-	std::vector<float> scaletime;
-	std::vector<float> forwards;
-	std::vector<float> backwards;
-	std::vector<Ogre::Vector3> tbcscale;
-	int stype;
-
-	
-	
+    std::string bonename;
+    //Rotations
+    std::vector<Ogre::Quaternion> quats;
+    std::vector<Ogre::Vector3> tbc;
+    std::vector<float> rottime;
+    float startTime;
+    float stopTime;
+    int rtype;
+
+    //Translations
+    std::vector<Ogre::Vector3> translist1;
+    std::vector<Ogre::Vector3> translist2;
+    std::vector<Ogre::Vector3> translist3;
+    std::vector<Ogre::Vector3> transtbc;
+    std::vector<float> transtime;
+    int ttype;
+
+    //Scalings
+    std::vector<float> scalefactor;
+    std::vector<float> scaletime;
+    std::vector<float> forwards;
+    std::vector<float> backwards;
+    std::vector<Ogre::Vector3> tbcscale;
+    int stype;
+
 public:
-	void clone(NiKeyframeData c)
-	{
-		quats = c.getQuat();
-		tbc = c.getrTbc();
-		rottime = c.getrTime();
+    void clone(const NiKeyframeData &c)
+    {
+        quats = c.getQuat();
+        tbc = c.getrTbc();
+        rottime = c.getrTime();
 
-		//types
-		ttype = c.getTtype();
-		rtype = c.getRtype();
-		stype = c.getStype();
+        //types
+        ttype = c.getTtype();
+        rtype = c.getRtype();
+        stype = c.getStype();
 
 
-		translist1 = c.getTranslist1();
-		translist2 =	c.getTranslist2();	
+        translist1 = c.getTranslist1();
+        translist2 =	c.getTranslist2();
         translist3 = c.getTranslist3();
 
-	    transtime = c.gettTime();
-	   
-	    bonename = c.getBonename();
-
-
-	}
-
-	void setBonename(std::string bone)
-	{
-		bonename = bone;
-	}
-	void setStartTime(float start)
-	{
-		startTime = start;
-	}
-  	void setStopTime(float end)
-	{
-		stopTime = end;
-	}
-  void read(NIFFile *nif)
-  {
-    // Rotations first
-    int count = nif->getInt();
-	//std::vector<Ogre::Quaternion> quat(count);
-	//std::vector<float> rottime(count);
-    if(count)
-      {
-
-		//TYPE1  LINEAR_KEY
-		//TYPE2  QUADRATIC_KEY
-		//TYPE3  TBC_KEY
-		//TYPE4  XYZ_ROTATION_KEY
-		//TYPE5  UNKNOWN_KEY
-        rtype = nif->getInt();
-		    //std::cout << "Count: " << count << "Type: " << type << "\n";
-
-        if(rtype == 1)
-		{
-			//We need to actually read in these values instead of skipping them
-			//nif->skip(count*4*5); // time + quaternion
-			for (int i = 0; i < count; i++) {
-			    float time = nif->getFloat();
-			    float w = nif->getFloat();
-			    float x = nif->getFloat();
-			    float y = nif->getFloat();
-			    float z = nif->getFloat();
-				Ogre::Quaternion quat = Ogre::Quaternion(Ogre::Real(w), Ogre::Real(x), Ogre::Real(y), Ogre::Real(z));
-				quats.push_back(quat);
-				rottime.push_back(time);
-				//if(time == 0.0 || time > 355.5) 
-					// std::cout <<"Time:" << time << "W:" << w <<"X:" << x << "Y:" << y << "Z:" << z << "\n";
-			}
-		}
-        else if(rtype == 3)
-		{                  //Example - node 116 in base_anim.nif
-			for (int i = 0; i < count; i++) {
-			    float time = nif->getFloat();
-			    float w = nif->getFloat();
-			    float x = nif->getFloat();
-			    float y = nif->getFloat();
-			    float z = nif->getFloat();
-
-				float tbcx = nif->getFloat();
-				float tbcy = nif->getFloat();
-				float tbcz = nif->getFloat();
-				Ogre::Quaternion quat = Ogre::Quaternion(Ogre::Real(w), Ogre::Real(x), Ogre::Real(y), Ogre::Real(z));
-				Ogre::Vector3 vec = Ogre::Vector3(tbcx, tbcy, tbcz);
-				quats.push_back(quat);
-				rottime.push_back(time);
-				tbc.push_back(vec);
-				//if(time == 0.0 || time > 355.5) 
-					// std::cout <<"Time:" << time << "W:" << w <<"X:" << x << "Y:" << y << "Z:" << z << "\n";
-			}
-
-          //nif->skip(count*4*8); // rot1 + tension+bias+continuity
-		}
-        else if(rtype == 4)
-          {
-            for(int j=0;j<count;j++)
-              {
-                nif->getFloat(); // time
-                for(int i=0; i<3; i++)
-                  {
-                    int cnt = nif->getInt();
-                    int type = nif->getInt();
-                    if(type == 1)
-                      nif->skip(cnt*4*2); // time + unknown
-                    else if(type == 2)
-                      nif->skip(cnt*4*4); // time + unknown vector
-                    else nif->fail("Unknown sub-rotation type");
-                  }
-              }
-          }
-        else nif->fail("Unknown rotation type in NiKeyframeData");
-      }
-	//first = false;
-
-    // Then translation
-    count = nif->getInt();
-	
-    if(count)
-      {
-       ttype = nif->getInt();
-
-		//std::cout << "TransCount:" << count << " Type: " << type << "\n";
-        if(ttype == 1) {
-			for (int i = 0; i < count; i++) {
-				float time = nif->getFloat();
-				float x = nif->getFloat();
-				float y = nif->getFloat();
-				float z = nif->getFloat();
-				Ogre::Vector3 trans = Ogre::Vector3(x, y, z);
-				translist1.push_back(trans);
-				transtime.push_back(time);
-			}
-			//nif->getFloatLen(count*4); // time + translation
-		}
-        else if(ttype == 2)
-		{                                        //Example - node 116 in base_anim.nif
-			for (int i = 0; i < count; i++) {
-				float time = nif->getFloat();
-				float x = nif->getFloat();
-				float y = nif->getFloat();
-				float z = nif->getFloat();
-				float x2 = nif->getFloat();
-				float y2 = nif->getFloat();
-				float z2 = nif->getFloat();
-				float x3 = nif->getFloat();
-				float y3 = nif->getFloat();
-				float z3 = nif->getFloat();
-				Ogre::Vector3 trans = Ogre::Vector3(x, y, z);
-				Ogre::Vector3 trans2 = Ogre::Vector3(x2, y2, z2);
-				Ogre::Vector3 trans3 = Ogre::Vector3(x3, y3, z3);
-				transtime.push_back(time);
-				translist1.push_back(trans);
-				translist2.push_back(trans2);
-				translist3.push_back(trans3);
-			}
-			
-			//nif->getFloatLen(count*10); // trans1 + forward + backward
-		}
-        else if(ttype == 3){
-			for (int i = 0; i < count; i++) {
-				float time = nif->getFloat();
-				float x = nif->getFloat();
-				float y = nif->getFloat();
-				float z = nif->getFloat();
-				float t = nif->getFloat();
-				float b = nif->getFloat();
-				float c = nif->getFloat();
-				Ogre::Vector3 trans = Ogre::Vector3(x, y, z);
-				Ogre::Vector3 tbc = Ogre::Vector3(t, b, c);
-				translist1.push_back(trans);
-				transtbc.push_back(tbc);
-				transtime.push_back(time);
-			}
-          //nif->getFloatLen(count*7); // trans1 + tension,bias,continuity
-		}
-        else nif->fail("Unknown translation type");
-      }
-
-    // Finally, scalings
-    count = nif->getInt();
-    if(count)
-      {
-        stype = nif->getInt();
-
-		
-		for(int i = 0; i < count; i++){
-					
-				
-        //int size = 0;
-        if(stype >= 1 && stype < 4) 
-			{
-				float time = nif->getFloat();
-				float scale = nif->getFloat();
-				scaletime.push_back(time);
-				scalefactor.push_back(scale);
-				//size = 2; // time+scale
-			}
-		else nif->fail("Unknown scaling type");
-         if(stype == 2){
-			//size = 4; // 1 + forward + backward (floats)
-			float forward = nif->getFloat();
-			float backward = nif->getFloat();
-			forwards.push_back(forward);
-			backwards.push_back(backward);
-		}
-		else if(stype == 3){
-			float tbcx = nif->getFloat();
-			float tbcy = nif->getFloat();
-			float tbcz = nif->getFloat();
-			Ogre::Vector3 vec = Ogre::Vector3(tbcx, tbcy, tbcz);
-			tbcscale.push_back(vec);
-
-			//size = 5; // 1 + tbc
-		}
-        
-		}
-      }
-	  else 
-		  stype = 0;
-  }
-  	int getRtype(){
-		return rtype;
-	}
-	int getStype(){
-		return stype;
-	}
-	int getTtype(){
-		return ttype;
-	}
-	float getStartTime(){
-		return startTime;
-	}
-	float getStopTime(){
-		return stopTime;
-	}
-	std::vector<Ogre::Quaternion> getQuat(){
-		return quats;
-	}
-	std::vector<Ogre::Vector3> getrTbc(){
-		return tbc;
-	}
-	std::vector<float> getrTime(){
-		return rottime;
-	}
-
-	std::vector<Ogre::Vector3> getTranslist1(){
-		return translist1;
-	}
-	std::vector<Ogre::Vector3> getTranslist2(){
-		return translist2;
-	}
-	std::vector<Ogre::Vector3> getTranslist3(){
-		return translist3;
-	}
-	std::vector<float> gettTime(){
-		return transtime;
-	}
-	std::vector<float> getScalefactor(){
-		return scalefactor;
-	}
-	std::vector<float> getForwards(){
-		return forwards;
-	}
-	std::vector<float> getBackwards(){
-		return backwards;
-	}
-	std::vector<Ogre::Vector3> getScaleTbc(){
-		return tbcscale;
-	}
-
-	std::vector<float> getsTime(){
-		return scaletime;
-	}
-	std::string getBonename(){ return bonename;
-	}
+        transtime = c.gettTime();
 
+        bonename = c.getBonename();
+    }
 
+    void setBonename(std::string bone)
+    { bonename = bone; }
+    void setStartTime(float start)
+    { startTime = start; }
+    void setStopTime(float end)
+    { stopTime = end; }
+
+    void read(NIFFile *nif)
+    {
+        // Rotations first
+        int count = nif->getInt();
+        //std::vector<Ogre::Quaternion> quat(count);
+        //std::vector<float> rottime(count);
+        if(count)
+        {
+            //TYPE1  LINEAR_KEY
+            //TYPE2  QUADRATIC_KEY
+            //TYPE3  TBC_KEY
+            //TYPE4  XYZ_ROTATION_KEY
+            //TYPE5  UNKNOWN_KEY
+            rtype = nif->getInt();
+            //std::cout << "Count: " << count << "Type: " << type << "\n";
+
+            if(rtype == 1)
+            {
+                //We need to actually read in these values instead of skipping them
+                //nif->skip(count*4*5); // time + quaternion
+                for (int i = 0; i < count; i++)
+                {
+                    float time = nif->getFloat();
+                    float w = nif->getFloat();
+                    float x = nif->getFloat();
+                    float y = nif->getFloat();
+                    float z = nif->getFloat();
+                    Ogre::Quaternion quat = Ogre::Quaternion(Ogre::Real(w), Ogre::Real(x), Ogre::Real(y), Ogre::Real(z));
+                    quats.push_back(quat);
+                    rottime.push_back(time);
+                    //if(time == 0.0 || time > 355.5)
+                    //    std::cout <<"Time:" << time << "W:" << w <<"X:" << x << "Y:" << y << "Z:" << z << "\n";
+                }
+            }
+            else if(rtype == 3)
+            {
+                //Example - node 116 in base_anim.nif
+                for (int i = 0; i < count; i++)
+                {
+                    float time = nif->getFloat();
+                    float w = nif->getFloat();
+                    float x = nif->getFloat();
+                    float y = nif->getFloat();
+                    float z = nif->getFloat();
+
+                    float tbcx = nif->getFloat();
+                    float tbcy = nif->getFloat();
+                    float tbcz = nif->getFloat();
+
+                    Ogre::Quaternion quat = Ogre::Quaternion(Ogre::Real(w), Ogre::Real(x), Ogre::Real(y), Ogre::Real(z));
+                    Ogre::Vector3 vec = Ogre::Vector3(tbcx, tbcy, tbcz);
+                    quats.push_back(quat);
+                    rottime.push_back(time);
+                    tbc.push_back(vec);
+                    //if(time == 0.0 || time > 355.5)
+                    //    std::cout <<"Time:" << time << "W:" << w <<"X:" << x << "Y:" << y << "Z:" << z << "\n";
+                }
+            }
+            else if(rtype == 4)
+            {
+                for(int j=0;j<count;j++)
+                {
+                    nif->getFloat(); // time
+                    for(int i=0; i<3; i++)
+                    {
+                        int cnt = nif->getInt();
+                        int type = nif->getInt();
+                        if(type == 1)
+                            nif->skip(cnt*4*2); // time + unknown
+                        else if(type == 2)
+                            nif->skip(cnt*4*4); // time + unknown vector
+                        else
+                            nif->fail("Unknown sub-rotation type");
+                    }
+                }
+            }
+            else
+                nif->fail("Unknown rotation type in NiKeyframeData");
+        }
+        //first = false;
+
+        // Then translation
+        count = nif->getInt();
+        if(count)
+        {
+            ttype = nif->getInt();
+
+            //std::cout << "TransCount:" << count << " Type: " << type << "\n";
+            if(ttype == 1)
+            {
+                for(int i = 0; i < count; i++)
+                {
+                    float time = nif->getFloat();
+                    float x = nif->getFloat();
+                    float y = nif->getFloat();
+                    float z = nif->getFloat();
+
+                    Ogre::Vector3 trans = Ogre::Vector3(x, y, z);
+                    translist1.push_back(trans);
+                    transtime.push_back(time);
+                }
+                //nif->getFloatLen(count*4); // time + translation
+            }
+            else if(ttype == 2)
+            {
+                //Example - node 116 in base_anim.nif
+                for(int i = 0; i < count; i++)
+                {
+                    float time = nif->getFloat();
+                    float x = nif->getFloat();
+                    float y = nif->getFloat();
+                    float z = nif->getFloat();
+                    float x2 = nif->getFloat();
+                    float y2 = nif->getFloat();
+                    float z2 = nif->getFloat();
+                    float x3 = nif->getFloat();
+                    float y3 = nif->getFloat();
+                    float z3 = nif->getFloat();
+
+                    Ogre::Vector3 trans = Ogre::Vector3(x, y, z);
+                    Ogre::Vector3 trans2 = Ogre::Vector3(x2, y2, z2);
+                    Ogre::Vector3 trans3 = Ogre::Vector3(x3, y3, z3);
+                    transtime.push_back(time);
+                    translist1.push_back(trans);
+                    translist2.push_back(trans2);
+                    translist3.push_back(trans3);
+                }
+
+                //nif->getFloatLen(count*10); // trans1 + forward + backward
+            }
+            else if(ttype == 3)
+            {
+                for(int i = 0; i < count; i++)
+                {
+                    float time = nif->getFloat();
+                    float x = nif->getFloat();
+                    float y = nif->getFloat();
+                    float z = nif->getFloat();
+                    float t = nif->getFloat();
+                    float b = nif->getFloat();
+                    float c = nif->getFloat();
+                    Ogre::Vector3 trans = Ogre::Vector3(x, y, z);
+                    Ogre::Vector3 tbc = Ogre::Vector3(t, b, c);
+                    translist1.push_back(trans);
+                    transtbc.push_back(tbc);
+                    transtime.push_back(time);
+                }
+            //nif->getFloatLen(count*7); // trans1 + tension,bias,continuity
+            }
+            else nif->fail("Unknown translation type");
+        }
+
+        // Finally, scalings
+        count = nif->getInt();
+        if(count)
+        {
+            stype = nif->getInt();
+
+            for(int i = 0; i < count; i++)
+            {
+                //int size = 0;
+                if(stype >= 1 && stype < 4)
+                {
+                    float time = nif->getFloat();
+                    float scale = nif->getFloat();
+                    scaletime.push_back(time);
+                    scalefactor.push_back(scale);
+                    //size = 2; // time+scale
+                }
+                else
+                    nif->fail("Unknown scaling type");
+
+                if(stype == 2)
+                {
+                    //size = 4; // 1 + forward + backward (floats)
+                    float forward = nif->getFloat();
+                    float backward = nif->getFloat();
+                    forwards.push_back(forward);
+                    backwards.push_back(backward);
+                }
+                else if(stype == 3)
+                {
+                    //size = 5; // 1 + tbc
+                    float tbcx = nif->getFloat();
+                    float tbcy = nif->getFloat();
+                    float tbcz = nif->getFloat();
+                    Ogre::Vector3 vec = Ogre::Vector3(tbcx, tbcy, tbcz);
+                    tbcscale.push_back(vec);
+                }
+            }
+        }
+        else
+            stype = 0;
+    }
+
+    int getRtype() const
+    { return rtype; }
+    int getStype() const
+    { return stype; }
+    int getTtype() const
+    { return ttype; }
+    float getStartTime() const
+    { return startTime; }
+    float getStopTime() const
+    { return stopTime; }
+    const std::vector<Ogre::Quaternion>& getQuat() const
+    { return quats; }
+    const std::vector<Ogre::Vector3>& getrTbc() const
+    { return tbc; }
+    const std::vector<float>& getrTime() const
+    { return rottime; }
+
+    const std::vector<Ogre::Vector3>& getTranslist1() const
+    { return translist1; }
+    const std::vector<Ogre::Vector3>& getTranslist2() const
+    { return translist2; }
+    const std::vector<Ogre::Vector3>& getTranslist3() const
+    { return translist3; }
+    const std::vector<float>& gettTime() const
+    { return transtime; }
+    const std::vector<float>& getScalefactor() const
+    { return scalefactor; }
+    const std::vector<float>& getForwards() const
+    { return forwards; }
+    const std::vector<float>& getBackwards() const
+    { return backwards; }
+    const std::vector<Ogre::Vector3>& getScaleTbc() const
+    { return tbcscale; }
+
+    const std::vector<float>& getsTime() const
+    { return scaletime; }
+    const std::string& getBonename() const
+    { return bonename; }
 };
 
 } // Namespace
diff --git a/components/nif/effect.hpp b/components/nif/effect.hpp
index b0cc64228..bac412c76 100644
--- a/components/nif/effect.hpp
+++ b/components/nif/effect.hpp
@@ -35,57 +35,62 @@ typedef Node Effect;
 // NiPointLight and NiSpotLight?
 struct NiLight : Effect
 {
-  struct SLight
-  {
-    float dimmer;
-    Vector ambient;
-    Vector diffuse;
-    Vector specular;
-  };
-
-  const SLight *light;
-
-  void read(NIFFile *nif)
-  {
-    Effect::read(nif);
-
-    nif->getInt(); // 1
-    nif->getInt(); // 1?
-    light = nif->getPtr<SLight>();
-  }
+    struct SLight
+    {
+        float dimmer;
+        Vector ambient;
+        Vector diffuse;
+        Vector specular;
+    };
+    const SLight *light;
+
+    void read(NIFFile *nif)
+    {
+        Effect::read(nif);
+
+        nif->getInt(); // 1
+        nif->getInt(); // 1?
+        light = nif->getPtr<SLight>();
+    }
 };
 
 struct NiTextureEffect : Effect
 {
-  NiSourceTexturePtr texture;
-
-  void read(NIFFile *nif)
-  {
-    Effect::read(nif);
-
-    int tmp = nif->getInt();
-    if(tmp) nif->getInt(); // always 1?
-
-    /*
-      3 x Vector4 = [1,0,0,0]
-      int = 2
-      int = 0 or 3
-      int = 2
-      int = 2
-     */
-    nif->skip(16*4);
-
-    texture.read(nif);
-
-    /*
-      byte = 0
-      vector4 = [1,0,0,0]
-      short = 0
-      short = -75
-      short = 0
-     */
-    nif->skip(23);
-  }
+    NiSourceTexturePtr texture;
+
+    void read(NIFFile *nif)
+    {
+        Effect::read(nif);
+
+        int tmp = nif->getInt();
+        if(tmp) nif->getInt(); // always 1?
+
+        /*
+           3 x Vector4 = [1,0,0,0]
+           int = 2
+           int = 0 or 3
+           int = 2
+           int = 2
+        */
+        nif->skip(16*4);
+
+        texture.read(nif);
+
+        /*
+           byte = 0
+           vector4 = [1,0,0,0]
+           short = 0
+           short = -75
+           short = 0
+        */
+        nif->skip(23);
+    }
+
+    void post(NIFFile *nif)
+    {
+        Effect::post(nif);
+        texture.post(nif);
+    }
 };
 
 } // Namespace
diff --git a/components/nif/extra.hpp b/components/nif/extra.hpp
index eec1aa7b4..ad788661a 100644
--- a/components/nif/extra.hpp
+++ b/components/nif/extra.hpp
@@ -38,70 +38,70 @@ namespace Nif
 class Extra : public Record
 {
 public:
-  ExtraPtr extra;
+    ExtraPtr extra;
 
-  void read(NIFFile *nif) { extra.read(nif); }
+    void read(NIFFile *nif) { extra.read(nif); }
+    void post(NIFFile *nif) { extra.post(nif); }
 };
 
 class NiVertWeightsExtraData : public Extra
 {
 public:
-  void read(NIFFile *nif)
-  {
-    Extra::read(nif);
+    void read(NIFFile *nif)
+    {
+        Extra::read(nif);
 
-    // We should have s*4+2 == i, for some reason. Might simply be the
-    // size of the rest of the record, unhelpful as that may be.
-    /*int i =*/ nif->getInt();
-    int s = nif->getShort(); // number of vertices
+        // We should have s*4+2 == i, for some reason. Might simply be the
+        // size of the rest of the record, unhelpful as that may be.
+        /*int i =*/ nif->getInt();
+        int s = nif->getShort(); // number of vertices
 
-    nif->getFloatLen(s);     // vertex weights I guess
-  }
+        nif->getFloatLen(s);     // vertex weights I guess
+    }
 };
 
 class NiTextKeyExtraData : public Extra
 {
 public:
-  struct TextKey
-  {
-    float time;
-    Misc::SString text;
-  };
-
-  std::vector<TextKey> list;
-
-  void read(NIFFile *nif)
-  {
-    Extra::read(nif);
-
-    nif->getInt(); // 0
-
-    int keynum = nif->getInt();
-    list.resize(keynum);
-    for(int i=0; i<keynum; i++)
-      {
-        list[i].time = nif->getFloat();
-        list[i].text = nif->getString();
-      }
-  }
+    struct TextKey
+    {
+        float time;
+        Misc::SString text;
+    };
+    std::vector<TextKey> list;
+
+    void read(NIFFile *nif)
+    {
+        Extra::read(nif);
+
+        nif->getInt(); // 0
+
+        int keynum = nif->getInt();
+        list.resize(keynum);
+        for(int i=0; i<keynum; i++)
+        {
+            list[i].time = nif->getFloat();
+            list[i].text = nif->getString();
+        }
+    }
 };
 
 class NiStringExtraData : public Extra
 {
 public:
-  /* Two known meanings:
-     "MRK" - marker, only visible in the editor, not rendered in-game
-     "NCO" - no collision
-   */
-  Misc::SString string;
-
-  void read(NIFFile *nif)
-  {
-    Extra::read(nif);
-
-    nif->getInt(); // size of string + 4. Really useful...
-    string = nif->getString();
-  }
+    /* Two known meanings:
+       "MRK" - marker, only visible in the editor, not rendered in-game
+       "NCO" - no collision
+    */
+    Misc::SString string;
+
+    void read(NIFFile *nif)
+    {
+        Extra::read(nif);
+
+        nif->getInt(); // size of string + 4. Really useful...
+        string = nif->getString();
+    }
 };
 
 } // Namespace
diff --git a/components/nif/nif_file.cpp b/components/nif/nif_file.cpp
index 80ea7a0b7..48dd76510 100644
--- a/components/nif/nif_file.cpp
+++ b/components/nif/nif_file.cpp
@@ -190,17 +190,23 @@ void NIFFile::parse()
 
 void NiSkinInstance::post(NIFFile *nif)
 {
-  int bnum = bones.length();
-  if(bnum != static_cast<int> (data->bones.size()))
-    nif->fail("Mismatch in NiSkinData bone count");
+    data.post(nif);
+    root.post(nif);
+    bones.post(nif);
 
-  root->makeRootBone(data->trafo);
+    if(data.empty() || root.empty())
+        nif->fail("NiSkinInstance missing root or data");
 
-  for(int i=0; i<bnum; i++)
-    {
-      if(!bones.has(i))
-        nif->fail("Oops: Missing bone! Don't know how to handle this.");
+    size_t bnum = bones.length();
+    if(bnum != data->bones.size())
+        nif->fail("Mismatch in NiSkinData bone count");
+
+    root->makeRootBone(data->trafo);
 
-      bones[i].makeBone(i, data->bones[i]);
+    for(int i=0; i<bnum; i++)
+    {
+        if(!bones.has(i))
+            nif->fail("Oops: Missing bone! Don't know how to handle this.");
+        bones[i].makeBone(i, data->bones[i]);
     }
 }
diff --git a/components/nif/nif_file.hpp b/components/nif/nif_file.hpp
index 951ae1f75..bb6f73259 100644
--- a/components/nif/nif_file.hpp
+++ b/components/nif/nif_file.hpp
@@ -43,113 +43,107 @@ namespace Nif
 
 class NIFFile
 {
-  enum NIFVersion
-    {
-      VER_MW    = 0x04000002    // Morrowind NIFs
+    enum NIFVersion {
+        VER_MW    = 0x04000002    // Morrowind NIFs
     };
 
-  /// Nif file version
-  int ver;
+    /// Nif file version
+    int ver;
 
-  /// Input stream
-  StreamPtr inp;
+    /// Input stream
+    StreamPtr inp;
 
-  /// File name, used for error messages
-  std::string filename;
+    /// File name, used for error messages
+    std::string filename;
 
-  /// Record list
-  std::vector<Record*> records;
+    /// Record list
+    std::vector<Record*> records;
 
-  /// Parse the file
-  void parse();
+    /// Parse the file
+    void parse();
 
- public:
-  /// Used for error handling
-  void fail(const std::string &msg)
+public:
+    /// Used for error handling
+    void fail(const std::string &msg)
     {
-      std::string err = "NIFFile Error: " + msg;
-      err += "\nFile: " + filename;
-      throw std::runtime_error(err);
+        std::string err = "NIFFile Error: " + msg;
+        err += "\nFile: " + filename;
+        throw std::runtime_error(err);
     }
 
-  /// Open a NIF stream. The name is used for error messages.
-  NIFFile(StreamPtr nif, const std::string &name)
-    : filename(name)
+    /// Open a NIF stream. The name is used for error messages.
+    NIFFile(StreamPtr nif, const std::string &name)
+      : filename(name)
     {
-      /* Load the entire file into memory. This allows us to use
-         direct pointers to the data arrays in the NIF, instead of
-         individually allocating and copying each one.
-
-         The NIF data is only stored temporarily in memory, since once
-         the mesh data is loaded it is siphoned into OGRE and
-         deleted. For that reason, we might improve this further and
-         use a shared region/pool based allocation scheme in the
-         future, especially since only one NIFFile will ever be loaded
-         at any given time.
-      */
-      inp = StreamPtr(new BufferStream(nif));
-
-      parse();
+        /* Load the entire file into memory. This allows us to use
+           direct pointers to the data arrays in the NIF, instead of
+           individually allocating and copying each one.
+
+           The NIF data is only stored temporarily in memory, since once
+           the mesh data is loaded it is siphoned into OGRE and
+           deleted. For that reason, we might improve this further and
+           use a shared region/pool based allocation scheme in the
+           future, especially since only one NIFFile will ever be loaded
+           at any given time.
+        */
+        inp = StreamPtr(new BufferStream(nif));
+
+        parse();
     }
 
-  ~NIFFile()
+    ~NIFFile()
     {
-      for(std::size_t i=0; i<records.size(); i++)
-        {
-          delete records[i];
-        }
+        for(std::size_t i=0; i<records.size(); i++)
+            delete records[i];
     }
 
-  /// Get a given record
-  Record *getRecord(int index)
-  {
-    assert(index >= 0 && index < static_cast<int> (records.size()));
-    Record *res = records[index];
-    assert(res != NULL);
-    return res;
-  }
-
-  /// Number of records
-  int numRecords() { return records.size(); }
+    /// Get a given record
+    Record *getRecord(size_t index)
+    {
+        Record *res = records.at(index);
+        assert(res != NULL);
+        return res;
+    }
 
-  /* ************************************************
+    /// Number of records
+    int numRecords() { return records.size(); }
 
+    /*************************************************
                Parser functions
+    ****************************************************/
 
-  ****************************************************/
-
-  void skip(size_t size) { inp->getPtr(size); }
+    void skip(size_t size) { inp->getPtr(size); }
 
-  template<class X> const X* getPtr() { return (const X*)inp->getPtr(sizeof(X)); }
-  template<class X> X getType() { return *getPtr<X>(); }
-  unsigned short getShort() { return getType<unsigned short>(); }
-  int getInt() { return getType<int>(); }
-  float getFloat() { return getType<float>(); }
-  char getByte() { return getType<char>(); }
+    template<class X> const X* getPtr() { return (const X*)inp->getPtr(sizeof(X)); }
+    template<class X> X getType() { return *getPtr<X>(); }
+    unsigned short getShort() { return getType<unsigned short>(); }
+    int getInt() { return getType<int>(); }
+    float getFloat() { return getType<float>(); }
+    char getByte() { return getType<char>(); }
 
-  template<class X>
-  Misc::SliceArray<X> getArrayLen(int num)
+    template<class X>
+    Misc::SliceArray<X> getArrayLen(int num)
     { return Misc::SliceArray<X>((const X*)inp->getPtr(num*sizeof(X)),num); }
 
-  template<class X>
-  Misc::SliceArray<X> getArray()
+    template<class X>
+    Misc::SliceArray<X> getArray()
     {
-      int len = getInt();
-      return getArrayLen<X>(len);
+        int len = getInt();
+        return getArrayLen<X>(len);
     }
 
-  Misc::SString getString() { return getArray<char>(); }
+    Misc::SString getString() { return getArray<char>(); }
 
-  const Vector *getVector() { return getPtr<Vector>(); }
-  const Matrix *getMatrix() { return getPtr<Matrix>(); }
-  const Transformation *getTrafo() { return getPtr<Transformation>(); }
-  const Vector4 *getVector4() { return getPtr<Vector4>(); }
+    const Vector *getVector() { return getPtr<Vector>(); }
+    const Matrix *getMatrix() { return getPtr<Matrix>(); }
+    const Transformation *getTrafo() { return getPtr<Transformation>(); }
+    const Vector4 *getVector4() { return getPtr<Vector4>(); }
 
-  Misc::FloatArray getFloatLen(int num)
+    Misc::FloatArray getFloatLen(int num)
     { return getArrayLen<float>(num); }
 
-  // For fixed-size strings where you already know the size
-  const char *getString(int size)
+    // For fixed-size strings where you already know the size
+    const char *getString(int size)
     { return (const char*)inp->getPtr(size); }
 };
 
diff --git a/components/nif/node.hpp b/components/nif/node.hpp
index 080042746..fe9d10c7a 100644
--- a/components/nif/node.hpp
+++ b/components/nif/node.hpp
@@ -26,6 +26,7 @@
 
 #include "controlled.hpp"
 #include "data.hpp"
+#include "property.hpp"
 
 namespace Nif
 {
@@ -37,191 +38,220 @@ namespace Nif
 class Node : public Named
 {
 public:
-  // Node flags. Interpretation depends somewhat on the type of node.
-  int flags;
-  const Transformation *trafo;
-  PropertyList props;
-
-  // Bounding box info
-  bool hasBounds;
-  const Vector *boundPos;
-  const Matrix *boundRot;
-  const Vector *boundXYZ; // Box size
-
-  void read(NIFFile *nif)
-  {
-    Named::read(nif);
-
-    flags = nif->getShort();
-    trafo = nif->getTrafo();
-    props.read(nif);
-
-    hasBounds = !!nif->getInt();
-    if(hasBounds)
-      {
-        nif->getInt(); // always 1
-        boundPos = nif->getVector();
-        boundRot = nif->getMatrix();
-        boundXYZ = nif->getVector();
-      }
-
-    boneTrafo = NULL;
-    boneIndex = -1;
-  }
-
-  // Bone transformation. If set, node is a part of a skeleton.
-  const NiSkinData::BoneTrafo *boneTrafo;
-
-  // Bone weight info, from NiSkinData
-  const NiSkinData::BoneInfo *boneInfo;
-
-  // Bone index. If -1, this node is either not a bone, or if
-  // boneTrafo is set it is the root bone in the skeleton.
-  short boneIndex;
-
-  void makeRootBone(const NiSkinData::BoneTrafo *tr)
-  {
-    boneTrafo = tr;
-    boneIndex = -1;
-  }
-
-  void makeBone(short ind, const NiSkinData::BoneInfo &bi)
-  {
-    boneInfo = &bi;
-    boneTrafo = bi.trafo;
-    boneIndex = ind;
-  }
+    // Node flags. Interpretation depends somewhat on the type of node.
+    int flags;
+    const Transformation *trafo;
+    PropertyList props;
+
+    // Bounding box info
+    bool hasBounds;
+    const Vector *boundPos;
+    const Matrix *boundRot;
+    const Vector *boundXYZ; // Box size
+
+    void read(NIFFile *nif)
+    {
+        Named::read(nif);
+
+        flags = nif->getShort();
+        trafo = nif->getTrafo();
+        props.read(nif);
+
+        hasBounds = !!nif->getInt();
+        if(hasBounds)
+        {
+            nif->getInt(); // always 1
+            boundPos = nif->getVector();
+            boundRot = nif->getMatrix();
+            boundXYZ = nif->getVector();
+        }
+
+        boneTrafo = NULL;
+        boneIndex = -1;
+    }
+
+    void post(NIFFile *nif)
+    {
+        Named::post(nif);
+        props.post(nif);
+    }
+
+    // Bone transformation. If set, node is a part of a skeleton.
+    const NiSkinData::BoneTrafo *boneTrafo;
+
+    // Bone weight info, from NiSkinData
+    const NiSkinData::BoneInfo *boneInfo;
+
+    // Bone index. If -1, this node is either not a bone, or if
+    // boneTrafo is set it is the root bone in the skeleton.
+    short boneIndex;
+
+    void makeRootBone(const NiSkinData::BoneTrafo *tr)
+    {
+        boneTrafo = tr;
+        boneIndex = -1;
+    }
+
+    void makeBone(short ind, const NiSkinData::BoneInfo &bi)
+    {
+        boneInfo = &bi;
+        boneTrafo = bi.trafo;
+        boneIndex = ind;
+    }
 };
 
 struct NiTriShapeCopy
 {
- std::string sname;
- std::vector<std::string> boneSequence;
- Nif::NiSkinData::BoneTrafoCopy trafo;
- //Ogre::Quaternion initialBoneRotation;
- //Ogre::Vector3 initialBoneTranslation;
- std::vector<Ogre::Vector3> vertices;
- std::vector<Ogre::Vector3> normals;
- std::vector<Nif::NiSkinData::BoneInfoCopy> boneinfo;
- std::map<int, std::vector<Nif::NiSkinData::IndividualWeight> > vertsToWeights;
- Nif::NiMorphData morph;
+    std::string sname;
+    std::vector<std::string> boneSequence;
+    Nif::NiSkinData::BoneTrafoCopy trafo;
+    //Ogre::Quaternion initialBoneRotation;
+    //Ogre::Vector3 initialBoneTranslation;
+    std::vector<Ogre::Vector3> vertices;
+    std::vector<Ogre::Vector3> normals;
+    std::vector<Nif::NiSkinData::BoneInfoCopy> boneinfo;
+    std::map<int, std::vector<Nif::NiSkinData::IndividualWeight> > vertsToWeights;
+    Nif::NiMorphData morph;
 };
 
 struct NiNode : Node
 {
-  NodeList children;
-  NodeList effects;
-
-  /* Known NiNode flags:
-
-     0x01 hidden
-     0x02 use mesh for collision
-     0x04 use bounding box for collision (?)
-     0x08 unknown, but common
-     0x20, 0x40, 0x80 unknown
-   */
-
-  void read(NIFFile *nif)
-  {
-    Node::read(nif);
-    children.read(nif);
-    effects.read(nif);
-  }
+    NodeList children;
+    NodeList effects;
+
+    /* Known NiNode flags:
+        0x01 hidden
+        0x02 use mesh for collision
+        0x04 use bounding box for collision (?)
+        0x08 unknown, but common
+        0x20, 0x40, 0x80 unknown
+    */
+
+    void read(NIFFile *nif)
+    {
+        Node::read(nif);
+        children.read(nif);
+        effects.read(nif);
+    }
+
+    void post(NIFFile *nif)
+    {
+        Node::post(nif);
+        children.post(nif);
+        effects.post(nif);
+    }
 };
 
 struct NiTriShape : Node
 {
-  /* Possible flags:
-     0x40 - mesh has no vertex normals ?
-
-     Only flags included in 0x47 (ie. 0x01, 0x02, 0x04 and 0x40) have
-     been observed so far.
-   */
-
-  NiTriShapeDataPtr data;
-  NiSkinInstancePtr skin;
-
-  void read(NIFFile *nif)
-  {
-    Node::read(nif);
-    data.read(nif);
-    skin.read(nif);
-  }
-
-  NiTriShapeCopy clone(){
-	  NiTriShapeCopy copy;
-      copy.sname = name.toString();
-	  float *ptr = (float*)data->vertices.ptr;
-	  float *ptrNormals = (float*)data->normals.ptr;
-	  int numVerts = data->vertices.length / 3;
-	  for(int i = 0; i < numVerts; i++)
-	  {
-		   float *current = (float*) (ptr + i * 3);
-		   copy.vertices.push_back(Ogre::Vector3(*current, *(current + 1), *(current + 2)));
-
-		   if(ptrNormals){
-			float *currentNormals = (float*) (ptrNormals + i * 3);
-		   copy.normals.push_back(Ogre::Vector3(*currentNormals, *(currentNormals + 1), *(currentNormals + 2)));
-	 		  }
-      }
-
-
-  return copy;
-  }
+    /* Possible flags:
+        0x40 - mesh has no vertex normals ?
+
+        Only flags included in 0x47 (ie. 0x01, 0x02, 0x04 and 0x40) have
+        been observed so far.
+    */
+
+    NiTriShapeDataPtr data;
+    NiSkinInstancePtr skin;
+
+    void read(NIFFile *nif)
+    {
+        Node::read(nif);
+        data.read(nif);
+        skin.read(nif);
+    }
+
+    void post(NIFFile *nif)
+    {
+        Node::post(nif);
+        data.post(nif);
+        skin.post(nif);
+    }
+
+    NiTriShapeCopy clone()
+    {
+        NiTriShapeCopy copy;
+        copy.sname = name.toString();
+        float *ptr = (float*)data->vertices.ptr;
+        float *ptrNormals = (float*)data->normals.ptr;
+        int numVerts = data->vertices.length / 3;
+        for(int i = 0; i < numVerts; i++)
+        {
+            float *current = (float*) (ptr + i * 3);
+            copy.vertices.push_back(Ogre::Vector3(*current, *(current + 1), *(current + 2)));
+
+            if(ptrNormals)
+            {
+                float *currentNormals = (float*) (ptrNormals + i * 3);
+                copy.normals.push_back(Ogre::Vector3(*currentNormals, *(currentNormals + 1), *(currentNormals + 2)));
+            }
+        }
+
+        return copy;
+    }
 };
 
 struct NiCamera : Node
 {
-  struct Camera
-  {
-    // Camera frustrum
-    float left, right, top, bottom, nearDist, farDist;
+    struct Camera
+    {
+        // Camera frustrum
+        float left, right, top, bottom, nearDist, farDist;
 
-    // Viewport
-    float vleft, vright, vtop, vbottom;
+        // Viewport
+        float vleft, vright, vtop, vbottom;
 
-    // Level of detail modifier
-    float LOD;
-  };
+        // Level of detail modifier
+        float LOD;
+    };
+    const Camera *cam;
 
-  const Camera *cam;
+    void read(NIFFile *nif)
+    {
+        Node::read(nif);
 
-  void read(NIFFile *nif)
-  {
-    Node::read(nif);
+        nif->getPtr<Camera>();
 
-    nif->getPtr<Camera>();
-
-    nif->getInt(); // -1
-    nif->getInt(); // 0
-  }
+        nif->getInt(); // -1
+        nif->getInt(); // 0
+    }
 };
 
 struct NiAutoNormalParticles : Node
 {
-  NiAutoNormalParticlesDataPtr data;
-
-  void read(NIFFile *nif)
-  {
-    Node::read(nif);
-    data.read(nif);
-    nif->getInt(); // -1
-  }
+    NiAutoNormalParticlesDataPtr data;
+
+    void read(NIFFile *nif)
+    {
+        Node::read(nif);
+        data.read(nif);
+        nif->getInt(); // -1
+    }
+
+    void post(NIFFile *nif)
+    {
+        Node::post(nif);
+        data.post(nif);
+    }
 };
 
 struct NiRotatingParticles : Node
 {
-  NiRotatingParticlesDataPtr data;
-
-  void read(NIFFile *nif)
-  {
-    Node::read(nif);
-    data.read(nif);
-    nif->getInt(); // -1
-  }
+    NiRotatingParticlesDataPtr data;
+
+    void read(NIFFile *nif)
+    {
+        Node::read(nif);
+        data.read(nif);
+        nif->getInt(); // -1
+    }
+
+    void post(NIFFile *nif)
+    {
+        Node::post(nif);
+        data.post(nif);
+    }
 };
 
-
-
 } // Namespace
 #endif
diff --git a/components/nif/property.hpp b/components/nif/property.hpp
index 1a16854af..619e3db0e 100644
--- a/components/nif/property.hpp
+++ b/components/nif/property.hpp
@@ -32,104 +32,116 @@ namespace Nif
 class Property : public Named
 {
 public:
-  // The meaning of these depends on the actual property type.
-  int flags;
-
-  void read(NIFFile *nif)
-  {
-    Named::read(nif);
-    flags = nif->getShort();
-  }
+    // The meaning of these depends on the actual property type.
+    int flags;
+
+    void read(NIFFile *nif)
+    {
+        Named::read(nif);
+        flags = nif->getShort();
+    }
 };
 
 class NiTexturingProperty : public Property
 {
 public:
-  // A sub-texture
-  struct Texture
-  {
-    /* Clamp mode
-       0 - clampS clampT
-       1 - clampS wrapT
-       2 - wrapS clampT
-       3 - wrapS wrapT
-    */
-
-    /* Filter:
-       0 - nearest
-       1 - bilinear
-       2 - trilinear
-       3, 4, 5 - who knows
+    // A sub-texture
+    struct Texture
+    {
+        /* Clamp mode
+        0 - clampS clampT
+        1 - clampS wrapT
+        2 - wrapS clampT
+        3 - wrapS wrapT
+        */
+
+        /* Filter:
+        0 - nearest
+        1 - bilinear
+        2 - trilinear
+        3, 4, 5 - who knows
+        */
+        bool inUse;
+        NiSourceTexturePtr texture;
+
+        int clamp, set, filter;
+        short unknown2;
+
+        void read(NIFFile *nif)
+        {
+            inUse = !!nif->getInt();
+            if(!inUse) return;
+
+            texture.read(nif);
+            clamp = nif->getInt();
+            filter = nif->getInt();
+            set = nif->getInt();
+
+            // I have no idea, but I think these are actually two
+            // PS2-specific shorts (ps2L and ps2K), followed by an unknown
+            // short.
+            nif->skip(6);
+        }
+
+        void post(NIFFile *nif)
+        {
+            texture.post(nif);
+        }
+    };
+
+    /* Apply mode:
+        0 - replace
+        1 - decal
+        2 - modulate
+        3 - hilight  // These two are for PS2 only?
+        4 - hilight2
     */
-    bool inUse;
-    NiSourceTexturePtr texture;
-
-    int clamp, set, filter;
-    short unknown2;
+    int apply;
+
+    /*
+     * The textures in this list are as follows:
+     *
+     * 0 - Base texture
+     * 1 - Dark texture
+     * 2 - Detail texture
+     * 3 - Gloss texture (never used?)
+     * 4 - Glow texture
+     * 5 - Bump map texture
+     * 6 - Decal texture
+     */
+    Texture textures[7];
 
     void read(NIFFile *nif)
     {
-      inUse = !!nif->getInt();
-      if(!inUse) return;
-
-      texture.read(nif);
-      clamp = nif->getInt();
-      filter = nif->getInt();
-      set = nif->getInt();
-
-      // I have no idea, but I think these are actually two
-      // PS2-specific shorts (ps2L and ps2K), followed by an unknown
-      // short.
-      nif->skip(6);
+        Property::read(nif);
+        apply = nif->getInt();
+
+        // Unknown, always 7. Probably the number of textures to read
+        // below
+        nif->getInt();
+
+        textures[0].read(nif); // Base
+        textures[1].read(nif); // Dark
+        textures[2].read(nif); // Detail
+        textures[3].read(nif); // Gloss (never present)
+        textures[4].read(nif); // Glow
+        textures[5].read(nif); // Bump map
+        if(textures[5].inUse)
+        {
+            // Ignore these at the moment
+            /*float lumaScale =*/ nif->getFloat();
+            /*float lumaOffset =*/ nif->getFloat();
+            /*const Vector4 *lumaMatrix =*/ nif->getVector4();
+        }
+        textures[6].read(nif); // Decal
+    }
+
+    void post(NIFFile *nif)
+    {
+        Property::post(nif);
+        for(int i = 0;i < 7;i++)
+            textures[i].post(nif);
     }
-  };
-
-  /* Apply mode:
-     0 - replace
-     1 - decal
-     2 - modulate
-     3 - hilight  // These two are for PS2 only?
-     4 - hilight2
-  */
-  int apply;
-
-  /*
-   * The textures in this list are as follows:
-   *
-   * 0 - Base texture
-   * 1 - Dark texture
-   * 2 - Detail texture
-   * 3 - Gloss texture (never used?)
-   * 4 - Glow texture
-   * 5 - Bump map texture
-   * 6 - Decal texture
-   */
-  Texture textures[7];
-
-  void read(NIFFile *nif)
-  {
-    Property::read(nif);
-    apply = nif->getInt();
-
-    // Unknown, always 7. Probably the number of textures to read
-    // below
-    nif->getInt();
-
-    textures[0].read(nif); // Base
-    textures[1].read(nif); // Dark
-    textures[2].read(nif); // Detail
-    textures[3].read(nif); // Gloss (never present)
-    textures[4].read(nif); // Glow
-    textures[5].read(nif); // Bump map
-    if(textures[5].inUse)
-      {
-        // Ignore these at the moment
-        /*float lumaScale =*/ nif->getFloat();
-        /*float lumaOffset =*/ nif->getFloat();
-        /*const Vector4 *lumaMatrix =*/ nif->getVector4();
-      }
-    textures[6].read(nif); // Decal
-  }
 };
 
 // These contain no other data than the 'flags' field in Property
@@ -140,88 +152,88 @@ typedef Property NiSpecularProperty;
 typedef Property NiWireframeProperty;
 
 // The rest are all struct-based
-template <typename Struct>
+template <typename T>
 struct StructPropT : Property
 {
-  const Struct* data;
+    const T* data;
 
-  void read(NIFFile *nif)
-  {
-    Property::read(nif);
-    data = nif->getPtr<Struct>();
-  }
+    void read(NIFFile *nif)
+    {
+        Property::read(nif);
+        data = nif->getPtr<T>();
+    }
 };
 
 struct S_MaterialProperty
 {
-  // The vector components are R,G,B
-  Vector ambient, diffuse, specular, emissive;
-  float glossiness, alpha;
+    // The vector components are R,G,B
+    Vector ambient, diffuse, specular, emissive;
+    float glossiness, alpha;
 };
 
 struct S_VertexColorProperty
 {
-  /* Vertex mode:
-     0 - source ignore
-     1 - source emmisive
-     2 - source amb diff
-
-     Lighting mode
-     0 - lighting emmisive
-     1 - lighting emmisive ambient/diffuse
-  */
-  int vertmode, lightmode;
+    /* Vertex mode:
+        0 - source ignore
+        1 - source emmisive
+        2 - source amb diff
+
+        Lighting mode
+        0 - lighting emmisive
+        1 - lighting emmisive ambient/diffuse
+    */
+    int vertmode, lightmode;
 };
 
 struct S_AlphaProperty
 {
-  /*
-    In NiAlphaProperty, the flags have the following meaning:
-
-    Bit 0 : alpha blending enable
-    Bits 1-4 : source blend mode
-    Bits 5-8 : destination blend mode
-    Bit 9 : alpha test enable
-    Bit 10-12 : alpha test mode
-    Bit 13 : no sorter flag ( disables triangle sorting )
-
-    blend modes (glBlendFunc):
-    0000 GL_ONE
-    0001 GL_ZERO
-    0010 GL_SRC_COLOR
-    0011 GL_ONE_MINUS_SRC_COLOR
-    0100 GL_DST_COLOR
-    0101 GL_ONE_MINUS_DST_COLOR
-    0110 GL_SRC_ALPHA
-    0111 GL_ONE_MINUS_SRC_ALPHA
-    1000 GL_DST_ALPHA
-    1001 GL_ONE_MINUS_DST_ALPHA
-    1010 GL_SRC_ALPHA_SATURATE
-
-    test modes (glAlphaFunc):
-    000 GL_ALWAYS
-    001 GL_LESS
-    010 GL_EQUAL
-    011 GL_LEQUAL
-    100 GL_GREATER
-    101 GL_NOTEQUAL
-    110 GL_GEQUAL
-    111 GL_NEVER
-
-    Taken from:
-    http://niftools.sourceforge.net/doc/nif/NiAlphaProperty.html
-
-    Right now we only use standard alpha blending (see the Ogre code
-    that sets it up) and it appears that this is the only blending
-    used in the original game. Bloodmoon (along with several mods) do
-    however use other settings, such as discarding pixel values with
-    alpha < 1.0. This is faster because we don't have to mess with the
-    depth stuff like we did for blending. And OGRE has settings for
-    this too.
-  */
-
-  // Tested against when certain flags are set (see above.)
-  unsigned char threshold;
+    /*
+        In NiAlphaProperty, the flags have the following meaning:
+
+        Bit 0 : alpha blending enable
+        Bits 1-4 : source blend mode
+        Bits 5-8 : destination blend mode
+        Bit 9 : alpha test enable
+        Bit 10-12 : alpha test mode
+        Bit 13 : no sorter flag ( disables triangle sorting )
+
+        blend modes (glBlendFunc):
+        0000 GL_ONE
+        0001 GL_ZERO
+        0010 GL_SRC_COLOR
+        0011 GL_ONE_MINUS_SRC_COLOR
+        0100 GL_DST_COLOR
+        0101 GL_ONE_MINUS_DST_COLOR
+        0110 GL_SRC_ALPHA
+        0111 GL_ONE_MINUS_SRC_ALPHA
+        1000 GL_DST_ALPHA
+        1001 GL_ONE_MINUS_DST_ALPHA
+        1010 GL_SRC_ALPHA_SATURATE
+
+        test modes (glAlphaFunc):
+        000 GL_ALWAYS
+        001 GL_LESS
+        010 GL_EQUAL
+        011 GL_LEQUAL
+        100 GL_GREATER
+        101 GL_NOTEQUAL
+        110 GL_GEQUAL
+        111 GL_NEVER
+
+        Taken from:
+        http://niftools.sourceforge.net/doc/nif/NiAlphaProperty.html
+
+        Right now we only use standard alpha blending (see the Ogre code
+        that sets it up) and it appears that this is the only blending
+        used in the original game. Bloodmoon (along with several mods) do
+        however use other settings, such as discarding pixel values with
+        alpha < 1.0. This is faster because we don't have to mess with the
+        depth stuff like we did for blending. And OGRE has settings for
+        this too.
+    */
+
+    // Tested against when certain flags are set (see above.)
+    unsigned char threshold;
 };
 
 typedef StructPropT<S_AlphaProperty> NiAlphaProperty;
diff --git a/components/nif/record.hpp b/components/nif/record.hpp
index 40f91f84f..06fdce55e 100644
--- a/components/nif/record.hpp
+++ b/components/nif/record.hpp
@@ -88,26 +88,25 @@ enum RecordType
 /// Base class for all records
 struct Record
 {
-  // Record type and type name
-  int recType;
-  Misc::SString recName;
+    // Record type and type name
+    int recType;
+    Misc::SString recName;
 
-  Record() : recType(RC_MISSING) {}
+    Record() : recType(RC_MISSING) {}
 
-  /// Parses the record from file
-  virtual void read(NIFFile *nif) = 0;
+    /// Parses the record from file
+    virtual void read(NIFFile *nif) = 0;
 
-  /// Does post-processing, after the entire tree is loaded
-  virtual void post(NIFFile *nif) {}
+    /// Does post-processing, after the entire tree is loaded
+    virtual void post(NIFFile *nif) {}
 
     virtual ~Record() {}
 
-  /*
-    Use these later if you want custom allocation of all NIF objects
-
-  static void* operator new(size_t size);
-  static void operator delete(void *p);
-  */
+    /*
+       Use these later if you want custom allocation of all NIF objects
+    static void* operator new(size_t size);
+    static void operator delete(void *p);
+    */
 };
 
 } // Namespace
diff --git a/components/nif/record_ptr.hpp b/components/nif/record_ptr.hpp
index c5618941e..ac91e25e3 100644
--- a/components/nif/record_ptr.hpp
+++ b/components/nif/record_ptr.hpp
@@ -37,61 +37,51 @@ namespace Nif
 template <class X>
 class RecordPtrT
 {
-  int index;
-  X* ptr;
-  NIFFile *nif;
-
- public:
-
-  RecordPtrT() : index(-2), ptr(NULL) {}
-
-  /// Read the index from the nif
-  void read(NIFFile *_nif)
-  {
-    // Can only read the index once
-    assert(index == -2);
-
-    // Store the NIFFile pointer for later
-    nif = _nif;
-
-    // And the index, of course
-    index = nif->getInt();
-  }
-
-  /** Set the pointer explicitly. May be used when you are pointing to
-      records in another file, eg. when you have a .nif / .kf pair.
-  */
-  void set(X *p)
-  {
-    ptr = p;
-    index = -1;
-  }
-
-  /// Look up the actual object from the index
-  X* getPtr()
-  {
-    // Have we found the pointer already?
-    if(ptr == NULL)
-      {
-        // Get the record
-        assert(index >= 0);
-        Record *r = nif->getRecord(index);
-
-        // And cast it
-        ptr = dynamic_cast<X*>(r);
-        assert(ptr != NULL);
-      }
-    return ptr;
-  }
+    union {
+        intptr_t index;
+        X* ptr;
+    };
 
-  /// Syntactic sugar
-  X* operator->() { return getPtr(); }
-  X& get() { return *getPtr(); }
+public:
+    RecordPtrT() : index(-2) {}
 
-  /// Pointers are allowed to be empty
-  bool empty() { return index == -1 && ptr == NULL; }
+    /// Read the index from the nif
+    void read(NIFFile *nif)
+    {
+        // Can only read the index once
+        assert(index == -2);
 
-  int getIndex() { return index; }
+        // Store the index for later
+        index = nif->getInt();
+    }
+
+    /// Resolve index to pointer
+    void post(NIFFile *nif)
+    {
+        if(index < 0)
+            ptr = NULL;
+        else
+        {
+            Record *r = nif->getRecord(index);
+            // And cast it
+            ptr = dynamic_cast<X*>(r);
+            assert(ptr != NULL);
+        }
+    }
+
+    /// Look up the actual object from the index
+    X* getPtr()
+    {
+        assert(ptr != NULL);
+        return ptr;
+    }
+    X& get() { return *getPtr(); }
+
+    /// Syntactic sugar
+    X* operator->() { return getPtr(); }
+
+    /// Pointers are allowed to be empty
+    bool empty() { return ptr == NULL; }
 };
 
 /** A list of references to other records. These are read as a list,
@@ -101,40 +91,38 @@ class RecordPtrT
 template <class X>
 class RecordListT
 {
-  typedef RecordPtrT<X> Ptr;
-  std::vector<Ptr> list;
-
- public:
+    typedef RecordPtrT<X> Ptr;
+    std::vector<Ptr> list;
 
-  void read(NIFFile *nif)
-  {
-    int len = nif->getInt();
-    list.resize(len);
+public:
+    void read(NIFFile *nif)
+    {
+        int len = nif->getInt();
+        list.resize(len);
 
-    assert(len >= 0 && len < 1000);
-    for(int i=0;i<len;i++)
-      list[i].read(nif);
-  }
+        for(size_t i=0;i < list.size();i++)
+            list[i].read(nif);
+    }
 
-  X& operator[](int index)
+    void post(NIFFile *nif)
     {
-      assert(index >= 0 && index < static_cast<int> (list.size()));
-      return list[index].get();
+        for(size_t i=0;i < list.size();i++)
+            list[i].post(nif);
     }
 
-  bool has(int index)
-  {
-    assert(index >= 0 && index < static_cast<int> (list.size()));
-    return !list[index].empty();
-  }
+    X& operator[](size_t index)
+    {
+        return list.at(index).get();
+    }
 
-  int getIndex(int index)
+    bool has(size_t index)
     {
-      if(has(index)) return list[index].getIndex();
-      else return -1;
+        assert(index >= 0 && index < static_cast<int> (list.size()));
+        return !list.at(index).empty();
     }
 
-  int length() { return list.size(); }
+    int length()
+    { return list.size(); }
 };