nif1

bool Mesh::CreateFromNIF(String filename)
{
    // Temporary stuffs
    File meshFile;

    // Open the mesh file
    ZeroMemory(&meshFile, sizeof(File));
    meshFile.Open(filename, File::Mode::Read);

    Log::Singleton->Write("Importing 3DS mesh: " + filename);

    // Begin importing the mesh

    NIF::Header header;
    // Load the header
    // Begin reading the string located at the beginning of the file
    Byte letter;
    header.Name = "";
    while((letter = meshFile.Read<Byte>()) != 0x0A) { header.Name += letter; };
    // Now read each data element individually because I can't be arsed to make this more efficient
    header.Version = meshFile.Read<UByte4>();
    header.Endianess = meshFile.Read<Byte>();
    header.UserVersion = meshFile.Read<UInt>();
    header.NumBlocks = meshFile.Read<UInt>();
    header.UserVersion2 = meshFile.Read<UInt>();
    // Export information
    header.Creator.Length = meshFile.Read<UByte>();
    header.Creator.Text += meshFile.Read<char>(header.Creator.Length);
    header.Info1.Length = meshFile.Read<UByte>();
    header.Info1.Text += meshFile.Read<char>(header.Info1.Length);
    header.Info2.Length = meshFile.Read<UByte>();
    header.Info2.Text += meshFile.Read<char>(header.Info2.Length);
    // Header again
    header.NumBlockTypes = meshFile.Read<UShort>();
    // Types of Blocks
    header.Types.resize(header.NumBlockTypes);
    for(Byte i = 0; i < header.NumBlockTypes; ++i)
    {
        header.Types[i].Length = meshFile.Read<UInt>();
        header.Types[i].Text += meshFile.Read<char>(header.Types[i].Length);
    }
    // Block Type ID linking thingy, idk
    header.BlockTypeIndex.resize(header.NumBlocks);
    meshFile.Read<UShort>(header.BlockTypeIndex.data(), header.NumBlocks);
    // omg why
    header.BlockSize.resize(header.NumBlocks);
    meshFile.Read<UInt>(header.BlockSize.data(), header.NumBlocks);
    // finally
    header.NumStrings = meshFile.Read<UInt>();
    header.MaxStringLength = meshFile.Read<UInt>();
    // or not, you're killing me
    header.Strings.resize(header.NumStrings);
    for(Byte i = 0; i < header.NumStrings; ++i)
    {
        header.Strings[i].Length = meshFile.Read<UInt>();
        header.Strings[i].Text += meshFile.Read<char>(header.Strings[i].Length);
    }
    //  I give up
    header.Unknown = meshFile.Read<UInt>();

    // THE MEATY MEAT
    // Set up the hash table
    const UInt hNIFNode = ELFHash("NiNode");
    const UInt hNIFTriShape = ELFHash("NiTriShape");

    for(Byte i = 0; i < header.NumBlocks; ++i)
    {
        String string = header.Types[header.BlockTypeIndex[i]].Text;
        UInt hash = ELFHash(string);
        //--//
        if(hash == hNIFNode) // NIF::Node ("NiNode")
        {
            NIF::Node node;
            // Now read the node
            node.Name = header.Strings[meshFile.Read<Int>()].Text; // String Reference
            node.NumExtraData = meshFile.Read<UInt>();
            node.ExtraData.resize(node.NumExtraData);
            meshFile.Read<UInt>(node.ExtraData.data(), node.NumExtraData); //[NumExtraData];
            node.Controller = meshFile.Read<Int>(); // Object Reference
            node.Flags = meshFile.Read<UShort>();
            node.Unknown = meshFile.Read<UShort>();
            node.Translation = meshFile.Read<Float3>();
            node.Rotation = meshFile.Read<Float3x3>();
            node.Scale = meshFile.Read<Float>();
            node.CollisionObject = meshFile.Read<Int>(); // Object Reference
            node.NumChildren = meshFile.Read<UInt>();
            node.Children.resize(node.NumChildren);
            meshFile.Read<Int>(node.Children.data(), node.NumChildren); // [NumChildren];
            node.NumEffects = meshFile.Read<UInt>();
            node.Effects.resize(node.NumEffects);
            meshFile.Read<Int>(node.Effects.data(), node.NumEffects); // [NumEffects];

            node.Unknown = header.Unknown;
        }
        else if(hash == hNIFTriShape) // NIF::TriShape ("NiTriShape")
        {
            NIF::TriShape node;
            // Now read the object data
            node.Name = header.Strings[meshFile.Read<Int>()].Text; // String Reference
            node.NumExtraData = meshFile.Read<UInt>();
            node.ExtraData.resize(node.NumExtraData);
            meshFile.Read<UInt>(node.ExtraData.data(), node.NumExtraData); //[NumExtraData];
            node.Controller = meshFile.Read<Int>();
            node.Flags = meshFile.Read<UShort>();
            node.Unknown = meshFile.Read<UShort>();
            node.Translation = meshFile.Read<Float3>();
            node.Rotation = meshFile.Read<Float3x3>();
            node.Scale = meshFile.Read<Float>();
            node.CollisionObject = meshFile.Read<Int>();
            node.Data = meshFile.Read<Int>();
            node.SkinInstance = meshFile.Read<Int>();
            node.NumMaterials = meshFile.Read<UInt>();
            assert(node.NumMaterials == 0);
            //Array<String> MaterialNames;
            //node.MaterialNames.resize(node.NumMaterials);
            //meshFile.Read<UInt>(node.MaterialNames.data(), node.NumMaterials); //[NumExtraData];
            //Array<Int> MaterialExtraData;
            node.ActiveMaterial = meshFile.Read<Int>();
            node.DirtyFlag = meshFile.Read<UByte>();
            node.Properties[0] = meshFile.Read<Int>();
            node.Properties[1] = meshFile.Read<Int>();

            node.Unknown = header.Unknown;
        }
        else
        {
            // Skip the chunk
            meshFile.Read<Byte>(header.BlockSize[i]);
        }
    }

    header.~Header();
    meshFile.Close();

    return false;
}