using System.Linq;
using System.Dynamic;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System;
using System.CodeDom.Compiler;
using System.CodeDom;
using System.Reflection;

namespace Red
{

    public partial class BlackObject : DynamicObject
    {
        string[] Names;
        string[] NamesUC;
        Dictionary<int, BlackObject> objects = new Dictionary<int, BlackObject>();
        string Type;
        BlackObject Parent = null;
        BlackObject Root = null;

        public BlackObject(Stream stream)
        {
            using (var br = new BinaryReader(stream))
            {
                var tmp = br.ReadUInt64();
                var len = br.ReadUInt32();
                var arrlen = br.ReadUInt16();
                var bytes = br.ReadBytes((int)len - 2);
                Names = Encoding.ASCII.GetString(bytes).Split('\0');
                len = br.ReadUInt32();
                arrlen = br.ReadUInt16();
                bytes = br.ReadBytes((int)len - 2);
                NamesUC = Encoding.Unicode.GetString(bytes).Split('\0');
                var index = br.ReadInt32();
                Create(br, index, br.ReadUInt32(), br.BaseStream.Position, null, this);
            }
        }

        long startInFile = 0;

        BlackObject(BinaryReader br, int? index, long len, long start, BlackObject parent, BlackObject root)
        {
            Create(br, index, len, start, parent, root);
        }
        void Create(BinaryReader br, int? index, long len, long start, BlackObject parent, BlackObject root)
        {
            Root = root;
            Parent = parent;
            var typeIndex = br.ReadInt16();
            Type = root.Names[typeIndex];
            if (index.HasValue)
            {
                if (index.Value == 83)
                {

                }
                root.objects[index.Value] = this;
                dictionary.Add("__i", index);
            }
            dictionary.Add("__t", Type);
            startInFile = start;
            while (br.BaseStream.Position < len + start)
            {
                var nameIndex = br.ReadInt16();
                var name = root.Names[nameIndex];
                if (name == "object" || name == "operator" || name == "")
                {
                    name += '_';
                }
                var key = new MK(Type, name);
                if (Readers.Keys.Contains(key))
                {
                    dictionary.Add(name, Readers[key].Item2(br, this, root, null));
                    continue;
                }
                var pos = br.BaseStream.Position;
                var value = br.ReadInt16();
                if (br.BaseStream.Position < len + start)
                {
                    var peek = br.ReadInt16();
                    if (peek == 0)
                    {
                        br.BaseStream.Position = pos;
                        var ind = br.ReadInt32();
                        var notAnArray = new string[] { "rotationCurve", "emissiveCurve", "scalingCurve", "transparentFlareMaterial", "flareMaterial", "kelvinColor", "noiseScaleCurve", "length", "observer", "transformBase", "lowDetailMesh", "mediumDetailMesh", "sourceObject", "destinationObject", "Tr2InstancedMesh", "instanceGeometryResource", "particleSystem", "mesh", "YCurve", "ZCurve", "XCurve", "decalEffect", "effect", "BlueCurve", "GreenCurve", "RedCurve", "AlphaCurve", "shader", "turretEffect" };
                        var sureAnArray = new string[] { "permuteTags", "parameterDescriptions", "transparentFlareData", "flareData", "lights", "systems", "enlightenAreas", "meshes", "transparentAreas", "subEmitters", "warheads", "flares", "stretch", "keys", "curveSets", "additiveEffects", "opaqueAreas", "children", "parameters", "damageLocators", "curves", "functions", "generators", "locators", "passes2Stage", "shaderMaterials", "areas" };
                        if (!sureAnArray.Contains(name) && ind == root.objects.Last().Key + 1)
                            dictionary.Add(name, ObjectReader(br, this, root, ind));
                        else if (notAnArray.Contains(name) && ind <= root.objects.Last().Key) //not an array so refference
                            dictionary.Add(name, CreateRef(ind));
                        else
                            dictionary.Add(name, ArrayReader(br, this, root, ind));
                    }
                    else
                    {
                        if (!dictionary.Keys.Contains(name))
                            dictionary.Add(name, root.Names[value]);
                        else
                        {
                            if (!(new string[] { "AudEmitterPersisted", "AudEmitter" }.Contains(Type) && name == "name"))
                                throw new ArgumentException();
                        }
                        br.BaseStream.Position = pos + 2;
                    }
                }
                else
                {
                    if (!dictionary.Keys.Contains(name))
                        dictionary.Add(name, root.Names[value]);
                    else
                    {
                        if (!(new string[] { "AudEmitterPersisted", "AudEmitter" }.Contains(Type) && name == "name"))
                            throw new ArgumentException();
                    }
                }
            }
        }

        BlackObject()
        {

        }

        BlackObject CreateRef(int index, bool real = true)
        {
            if(real)
                return Root.objects[index];
            var ret = new BlackObject();
            ret.dictionary["__t"] = "_Ref";
            ret.dictionary["__ri"] = index;
            ret.Root = Root;
            ret.Parent = Parent;
            return ret;
        }


        class MK : Tuple<string, string>
        {
            public MK(string Type, string Name) : base(Type, Name) { }
        }
        class MKF : Tuple<MK, Reader>
        {
            public MKF(MK Key, Reader ReaderFunction) : base(Key, ReaderFunction) { }
            public MKF(string Type, string Name, Reader ReaderFunction) : base(new MK(Type, Name), ReaderFunction) { }
        }
        delegate object Reader(BinaryReader br, BlackObject me, BlackObject root, int? index);
        
        //static DateTime fileDateStart = new DateTime(1600)
        static readonly Reader Float4Reader = (br, me, root, index) => new float[] { br.ReadSingle(), br.ReadSingle(), br.ReadSingle(), br.ReadSingle() };
        static readonly Reader Float3Reader = (br, me, root, index) => new float[] { br.ReadSingle(), br.ReadSingle(), br.ReadSingle() };
        static readonly Reader Float2Reader = (br, me, root, index) => new float[] { br.ReadSingle(), br.ReadSingle()};
        static readonly Reader DoubleReader = (br, me, root, index) => br.ReadDouble();
        static readonly Reader Int64Reader = (br, me, root, index) => br.ReadInt64();
        static readonly Reader DateReader = (br, me, root, index) => DateTime.FromFileTime(br.ReadInt64());
        static readonly Reader FloatReader = (br, me, root, index) => br.ReadSingle();
        static readonly Reader Int32Reader = (br, me, root, index) => br.ReadInt32();
        static readonly Reader Int322Reader = (br, me, root, index) => new int[] { br.ReadInt32(), br.ReadInt32() };
        static readonly Reader Int323Reader = (br, me, root, index) => new int[] { br.ReadInt32(), br.ReadInt32(), br.ReadInt32() };
        static readonly Reader BoolReader = (br, me, root, index) => (br.ReadByte() == 1);
        static readonly Reader NameReader = (br, me, root, index) => root.Names[br.ReadInt16()];
        static readonly Reader NameUCReader = (br, me, root, index) => root.NamesUC[br.ReadInt16()];
        static readonly Reader ObjectWithoutIndexReader = (br, me, root, index) => new BlackObject(br, index, br.ReadInt32(), br.BaseStream.Position, me, root);
        static readonly Reader DebugThrow = (br, me, root, index) => { throw new Exception(); };
        static readonly Reader ByteReader = (br, me, root, index) => br.ReadByte();
        static readonly Reader Matrix4x4Reader = (br, me, root, index) =>
        {
            var matrix = new float[16];
            for (int i = 0; i < 16; i++)
                matrix[i] = br.ReadSingle();
            return matrix;
        };
        static readonly Reader ObjectReader = (br, me, root, index) =>
        {
            return new BlackObject(br, index, br.ReadUInt32(), br.BaseStream.Position, me, root);
        };
        static readonly Reader DictionaryReader = (br, me, root, index) =>
        {
            Dictionary<string, dynamic> ret = new Dictionary<string, dynamic>();
            int count = br.ReadInt32();
            for (int i = 0; i < count; i++)
            {
                var ind = br.ReadInt16();
                var newindex = br.ReadInt32();
                if (newindex == root.objects.Last().Key + 1)
                    ret[me.Root.Names[ind]] = ObjectReader(br, me, root, newindex);
                else
                    ret[me.Root.Names[ind]] = me.CreateRef(newindex);

            }
            return ret;
        };
        static readonly Reader ArrayReader = (br, me, root, index) =>
        {

            var arr = new List<dynamic>((int)index);

            for (int i = 0; i < index; i++)
            {
                var newindex = br.ReadInt32();
                if (newindex <= root.objects.Last().Key)
                    arr.Add(me.CreateRef(newindex));
                else if (newindex == root.objects.Last().Key + 1)
                    arr.Add(new BlackObject(br, newindex, br.ReadUInt32(), br.BaseStream.Position, me, root));
                else
                    throw new Exception("Array len > array real elemns!");
            }
            return arr;
        };

        static readonly Dictionary<MK, MKF> Readers =
        new MKF[] {
            new MKF("EveBoosterSet2", "alwaysOn", BoolReader),
            new MKF("EveBoosterSet2", "destinyUpdate", BoolReader),
            new MKF("EveBoosterSet2", "glowColor", ObjectWithoutIndexReader),
            new MKF("EveBoosterSet2", "glowScale", FloatReader),
            new MKF("EveBoosterSet2", "haloColor", ObjectWithoutIndexReader),
            new MKF("EveBoosterSet2", "haloScaleX", FloatReader),
            new MKF("EveBoosterSet2", "haloScaleY", FloatReader),
            new MKF("EveBoosterSet2", "symHaloScale", FloatReader),
            new MKF("EveBoosterSet2", "trailsStaticOffsets1", Float3Reader),
            new MKF("EveBoosterSet2", "trailsStaticOffsets2", Float3Reader),
            new MKF("EveBoosterSet2", "trailsStaticOffsets3", Float3Reader),
            new MKF("EveBoosterSet2", "trailsStaticOffsets4", Float3Reader),
            new MKF("EveCamera", "alignment", ObjectWithoutIndexReader),
            new MKF("EveCamera", "angleOffsetScale", FloatReader),
            new MKF("EveCamera", "dampening", FloatReader),
            new MKF("EveCamera", "exponent", FloatReader),
            new MKF("EveCamera", "fieldOfView", FloatReader),
            new MKF("EveCamera", "friction", FloatReader),
            new MKF("EveCamera", "frontClip", FloatReader),
            new MKF("EveCamera", "idleMove", BoolReader),
            new MKF("EveCamera", "idleScale", FloatReader),
            new MKF("EveCamera", "idleSpeed", FloatReader),
            new MKF("EveCamera", "intr", ObjectWithoutIndexReader),
            new MKF("EveCamera", "maxSpeed", FloatReader),
            new MKF("EveCamera", "noiseScale", FloatReader),
            new MKF("EveCamera", "pitch", FloatReader),
            new MKF("EveCamera", "pitchMultiplier", FloatReader),
            new MKF("EveCamera", "pos", ObjectWithoutIndexReader),
            new MKF("EveCamera", "projection", ObjectWithoutIndexReader),
            new MKF("EveCamera", "rotationAroundParent", ObjectWithoutIndexReader),
            new MKF("EveCamera", "rotationOfInterest", ObjectWithoutIndexReader),
            new MKF("EveCamera", "translationFromParent", ObjectWithoutIndexReader),
            new MKF("EveCamera", "view", ObjectWithoutIndexReader),
            new MKF("EveCamera", "yaw", FloatReader),
            new MKF("EveCamera", "yawMultiplier", FloatReader),
            new MKF("EveCamera", "zoomCurve", ObjectWithoutIndexReader),
            new MKF("EveDustfield", "maxStretch", FloatReader),
            new MKF("EveDustfield", "stretch", FloatReader),
            new MKF("EveEmitterSpherical", "atlasTextureCount", Int32Reader),
            new MKF("EveEmitterSpherical", "maxLifetime", FloatReader),
            new MKF("EveEmitterSpherical", "maxMass", FloatReader),
            new MKF("EveEmitterSpherical", "maxPhi", FloatReader),
            new MKF("EveEmitterSpherical", "maxRadius", FloatReader),
            new MKF("EveEmitterSpherical", "maxRotationInit", FloatReader),
            new MKF("EveEmitterSpherical", "maxRotationVelo", FloatReader),
            new MKF("EveEmitterSpherical", "maxSizeBirth", FloatReader),
            new MKF("EveEmitterSpherical", "maxSizeDeath", FloatReader),
            new MKF("EveEmitterSpherical", "maxTheta", FloatReader),
            new MKF("EveEmitterSpherical", "maxVelocity", FloatReader),
            new MKF("EveEmitterSpherical", "minLifetime", FloatReader),
            new MKF("EveEmitterSpherical", "minMass", FloatReader),
            new MKF("EveEmitterSpherical", "minPhi", FloatReader),
            new MKF("EveEmitterSpherical", "minRadius", FloatReader),
            new MKF("EveEmitterSpherical", "minRotationVelo", FloatReader),
            new MKF("EveEmitterSpherical", "minSizeBirth", FloatReader),
            new MKF("EveEmitterSpherical", "minSizeDeath", FloatReader),
            new MKF("EveEmitterSpherical", "minVelocity", FloatReader),
            new MKF("EveEmitterSpherical", "position", Float3Reader),
            new MKF("EveEmitterSpherical", "rotation", Float4Reader),
            new MKF("EveEmitterSpherical", "spawnRate", FloatReader),
            new MKF("EveEmitterStaticData", "atlasID", Int32Reader),
            new MKF("EveEmitterStaticData", "color", Float4Reader),
            new MKF("EveEmitterStaticData", "position", Float3Reader),
            new MKF("EveEmitterStaticData", "size", FloatReader),
            new MKF("EveLensflare", "position", Float3Reader),
            new MKF("EveLocator2", "transform", Matrix4x4Reader),
            new MKF("EveMissile", "boundingSphereCenter", Float3Reader),
            new MKF("EveMissile", "boundingSphereRadius", FloatReader),
            new MKF("EveMissile", "fadeOutInhertitedVeloDelay", FloatReader),
            new MKF("EveMissile", "fadeOutInhertitedVeloSpeed", FloatReader),
            new MKF("EveMissileWarhead", "acceleration", FloatReader),
            new MKF("EveMissileWarhead", "durationEjectPhase", FloatReader),
            new MKF("EveMissileWarhead", "maxExplosionDistance", FloatReader),
            new MKF("EveMissileWarhead", "startEjectVelocity", FloatReader),
            new MKF("EveParticleDirectForce", "force", Float3Reader),
            new MKF("EveParticleDragForce", "drag", FloatReader),
            new MKF("EveParticleSpring", "springConstant", FloatReader),
            new MKF("EveRootTransform", "boundingSphereCenter", Float3Reader),
            new MKF("EveRootTransform", "boundingSphereRadius", FloatReader),
            new MKF("EveRootTransform", "debugShowBoundingBox", BoolReader),
            new MKF("EveRootTransform", "modifier", Int32Reader),
            new MKF("EveRootTransform", "scaling", Float3Reader),
            new MKF("EveRootTransform", "translation", Float3Reader),
            new MKF("EveShip2", "boundingSphereCenter", Float3Reader),
            new MKF("EveShip2", "boundingSphereRadius", FloatReader),
            new MKF("EveShip2", "debugShowBoundingBox", BoolReader),
            new MKF("EveShipAnimCurve", "gr2BoneIndex", Int32Reader),
            new MKF("EveSpaceObjectDecal", "position", Float3Reader),
            new MKF("EveSpaceObjectDecal", "rotation", Float4Reader),
            new MKF("EveSpaceObjectDecal", "scaling", Float3Reader),
            new MKF("EveSpaceScene", "ambientColor", Float4Reader),
            new MKF("EveSpaceScene", "backgroundRenderingEnabled", BoolReader),
            new MKF("EveSpaceScene", "enableShadows", BoolReader),
            new MKF("EveSpaceScene", "envMapRotation", Float4Reader),
            new MKF("EveSpaceScene", "envMapScaling", Float3Reader),
            new MKF("EveSpaceScene", "fogColor", Float4Reader),
            new MKF("EveSpaceScene", "fogEnd", FloatReader),
            new MKF("EveSpaceScene", "fogMax", FloatReader),
            new MKF("EveSpaceScene", "fogStart", FloatReader),
            new MKF("EveSpaceScene", "selfShadowOnly", BoolReader),
            new MKF("EveSpaceScene", "shadowFadeThreshold", FloatReader),
            new MKF("EveSpaceScene", "shadowThreshold", FloatReader),
            new MKF("EveSpaceScene", "sunDiffuseColor", Float4Reader),
            new MKF("EveSpaceScene", "sunDirection", Float3Reader),
            new MKF("EveSpherePin", "centerNormal", Float3Reader),
            new MKF("EveSpherePin", "enablePicking", BoolReader),
            new MKF("EveSpherePin", "pinColor", Float4Reader),
            new MKF("EveSpherePin", "pinMaxRadius", FloatReader),
            new MKF("EveSpherePin", "pinRadius", FloatReader),
            new MKF("EveSpherePin", "sortValueMultiplier", FloatReader),
            new MKF("EveSpriteParticleSystem", "applyForce", BoolReader),
            new MKF("EveSpriteParticleSystem", "color1", Float4Reader),
            new MKF("EveSpriteParticleSystem", "color2", Float4Reader),
            new MKF("EveSpriteParticleSystem", "color3", Float4Reader),
            new MKF("EveSpriteParticleSystem", "colorMidpoint", FloatReader),
            new MKF("EveSpriteParticleSystem", "maxParticleCount", Int32Reader),
            new MKF("EveSpriteParticleSystem", "updateSimulation", BoolReader),
            new MKF("EveSpriteParticleSystem", "useWorldScale", BoolReader),
            new MKF("EveSpriteParticleSystem", "velocityStretch", FloatReader),
            new MKF("EveSpriteSet", "display", BoolReader),
            new MKF("EveSpriteSetItem", "blinkPhase", FloatReader),
            new MKF("EveSpriteSetItem", "blinkRate", FloatReader),
            new MKF("EveSpriteSetItem", "color", ObjectWithoutIndexReader),
            new MKF("EveSpriteSetItem", "falloff", FloatReader),
            new MKF("EveSpriteSetItem", "maxScale", FloatReader),
            new MKF("EveSpriteSetItem", "minScale", FloatReader),
            new MKF("EveSpriteSetItem", "position", ObjectWithoutIndexReader),
            new MKF("EveStarfield", "maxDist", FloatReader),
            new MKF("EveStarfield", "maxFlashRate", FloatReader),
            new MKF("EveStarfield", "minFlashIntensity", FloatReader),
            new MKF("EveStarfield", "minFlashRate", FloatReader),
            new MKF("EveStarfield", "numStars", Int32Reader),
            new MKF("EveStarfield", "seed", FloatReader),
            new MKF("EveStation2", "boundingSphereCenter", Float3Reader),
            new MKF("EveStation2", "boundingSphereRadius", FloatReader),
            new MKF("EveStation2", "debugShowBoundingBox", BoolReader),
            new MKF("EveStation2", "modelScale", FloatReader),
            new MKF("EveTransform", "debugRenderDebugInfoForChildren", BoolReader),
            new MKF("EveTransform", "debugShowBoundingBox", BoolReader),
            new MKF("EveTransform", "display", BoolReader),
            new MKF("EveTransform", "distanceBasedScaleArg1", FloatReader),
            new MKF("EveTransform", "distanceBasedScaleArg2", FloatReader),
            new MKF("EveTransform", "modifier", Int32Reader),
            new MKF("EveTransform", "rotation", Float4Reader),
            new MKF("EveTransform", "scaling", Float3Reader),
            new MKF("EveTransform", "sortValueMultiplier", FloatReader),
            new MKF("EveTransform", "translation", Float3Reader),
            new MKF("EveTransform", "update", BoolReader),
            new MKF("EveTransform", "useDistanceBasedScale", BoolReader),
            new MKF("EveTransform", "visibilityThreshold", FloatReader),
            new MKF("EveTurretFiringFX", "firingDelay1", FloatReader),
            new MKF("EveTurretFiringFX", "firingDelay2", FloatReader),
            new MKF("EveTurretFiringFX", "firingDelay3", FloatReader),
            new MKF("EveTurretFiringFX", "firingDelay4", FloatReader),
            new MKF("EveTurretFiringFX", "isLoopFiring", BoolReader),
            new MKF("EveTurretFiringFX", "useMuzzleTransform", BoolReader),
            new MKF("EveTurretSet", "alternateFiringAnimCount", Int32Reader),
            new MKF("EveTurretSet", "bottomClipHeight", FloatReader),
            new MKF("EveTurretSet", "boundingSphere", Float4Reader),
            new MKF("EveTurretSet", "hasCyclingFiringPos", BoolReader),
            new MKF("EveTurretSet", "sysBoneHeight", FloatReader),
            new MKF("EveTurretSet", "sysBonePitch01Factor", FloatReader),
            new MKF("EveTurretSet", "sysBonePitch02Factor", FloatReader),
            new MKF("EveTurretSet", "sysBonePitchFactor", FloatReader),
            new MKF("EveTurretSet", "sysBonePitchMin", FloatReader),
            new MKF("EveTurretSet", "sysBonePitchOffset", FloatReader),
            new MKF("EveTurretSet", "useRandomFiringDelay", BoolReader),
            new MKF("Tr2ClothingActor", "effectReversed", Int32Reader),
            new MKF("Tr2ClothingActor", "morphResEpsilon", FloatReader),
            new MKF("Tr2ColorCurve", "cycle", BoolReader),
            new MKF("Tr2ColorCurve", "endValue", Float4Reader),
            new MKF("Tr2ColorCurve", "length", FloatReader),
            new MKF("Tr2ColorCurve", "startValue", Float4Reader),
            new MKF("Tr2ColorKey", "time", FloatReader),
            new MKF("Tr2ColorKey", "value", Float4Reader),
            new MKF("Tr2DistanceTracker", "direction", Float3Reader),
            new MKF("Tr2DistanceTracker", "targetPosition", Float3Reader),
            new MKF("Tr2DynamicEmitter", "rate", FloatReader),
            new MKF("Tr2Effect", "useMaxSupportedShaderModel", BoolReader),
            new MKF("Tr2EmitterSpherical", "atlasTextureCount", Int32Reader),
            new MKF("Tr2EmitterSpherical", "maxLifetime", FloatReader),
            new MKF("Tr2EmitterSpherical", "maxPhi", FloatReader),
            new MKF("Tr2EmitterSpherical", "maxRotationInit", FloatReader),
            new MKF("Tr2EmitterSpherical", "maxRotationVelo", FloatReader),
            new MKF("Tr2EmitterSpherical", "maxSizeBirth", FloatReader),
            new MKF("Tr2EmitterSpherical", "maxSizeDeath", FloatReader),
            new MKF("Tr2EmitterSpherical", "maxTheta", FloatReader),
            new MKF("Tr2EmitterSpherical", "maxVelocity", FloatReader),
            new MKF("Tr2EmitterSpherical", "minLifetime", FloatReader),
            new MKF("Tr2EmitterSpherical", "minPhi", FloatReader),
            new MKF("Tr2EmitterSpherical", "minRotationVelo", FloatReader),
            new MKF("Tr2EmitterSpherical", "minSizeBirth", FloatReader),
            new MKF("Tr2EmitterSpherical", "minSizeDeath", FloatReader),
            new MKF("Tr2EmitterSpherical", "minTheta", FloatReader),
            new MKF("Tr2EmitterSpherical", "minVelocity", FloatReader),
            new MKF("Tr2EmitterSpherical", "position", Float3Reader),
            new MKF("Tr2EmitterSpherical", "rotation", Float4Reader),
            new MKF("Tr2EmitterSpherical", "spawnRate", FloatReader),
            new MKF("Tr2EnlightenArea", "albedoColor", Float4Reader),
            new MKF("Tr2EnlightenArea", "emissiveColor", Float4Reader),
            new MKF("Tr2EnlightenArea", "index", Int32Reader),
            new MKF("Tr2EnlightenArea", "isEmissive", BoolReader),
            new MKF("Tr2FloatParameter", "value", FloatReader),
            new MKF("Tr2GPUParticleEmitter", "lastPosValid", BoolReader),
            new MKF("Tr2GPUParticleSubEmitter", "emissionDensity", FloatReader),
            new MKF("Tr2GPUParticleSubEmitter", "emissionRate", FloatReader),
            new MKF("Tr2GPUParticleSubEmitter", "inheritVelocity", FloatReader),
            new MKF("Tr2GPUParticleSubEmitter", "positionScale", FloatReader),
            new MKF("Tr2GPUParticleSubEmitter", "velocityScale", FloatReader),
            new MKF("Tr2GPUParticleType", "angularVelocity", FloatReader),
            new MKF("Tr2GPUParticleType", "color0", Float4Reader),
            new MKF("Tr2GPUParticleType", "color1", Float4Reader),
            new MKF("Tr2GPUParticleType", "color2", Float4Reader),
            new MKF("Tr2GPUParticleType", "color3", Float4Reader),
            new MKF("Tr2GPUParticleType", "dragFactor", FloatReader),
            new MKF("Tr2GPUParticleType", "gravityWeight", FloatReader),
            new MKF("Tr2GPUParticleType", "lifespan", FloatReader),
            new MKF("Tr2GPUParticleType", "lifespanVariance", FloatReader),
            new MKF("Tr2GPUParticleType", "renderMode", Int32Reader),
            new MKF("Tr2GPUParticleType", "size", Float3Reader),
            new MKF("Tr2GPUParticleType", "sizeVariance", FloatReader),
            new MKF("Tr2GPUParticleType", "turbulenceWeight", FloatReader),
            new MKF("Tr2InstancedMesh", "maxBounds", Float3Reader),
            new MKF("Tr2InstancedMesh", "minBounds", Float3Reader),
            new MKF("Tr2InteriorCell", "isUnbounded", BoolReader),
            new MKF("Tr2InteriorEnlightenSystem", "systemID", Int32Reader),
            new MKF("Tr2InteriorFlare", "color", Float4Reader),
            new MKF("Tr2InteriorFlare", "occluderSize", FloatReader),
            new MKF("Tr2InteriorFlare", "transform", Matrix4x4Reader),
            new MKF("Tr2InteriorFlareData", "centerFadeMaxRadius", FloatReader),
            new MKF("Tr2InteriorFlareData", "centerFadeMinRadius", FloatReader),
            new MKF("Tr2InteriorFlareData", "directionalStretch", Float2Reader),
            new MKF("Tr2InteriorFlareData", "edgeFadeDistance", FloatReader),
            new MKF("Tr2InteriorFlareData", "positionWeight", Float2Reader),
            new MKF("Tr2InteriorFlareData", "rotation", BoolReader),
            new MKF("Tr2InteriorFlareData", "size", Float2Reader),
            new MKF("Tr2InteriorFlareData", "textureOffset", Float2Reader),
            new MKF("Tr2InteriorFlareData", "textureSize", Float2Reader),
            new MKF("Tr2InteriorLightSource", "affectTransparentObjects", BoolReader),
            new MKF("Tr2InteriorLightSource", "color", Float4Reader),
            new MKF("Tr2InteriorLightSource", "coneAlphaInner", FloatReader),
            new MKF("Tr2InteriorLightSource", "coneAlphaOuter", FloatReader),
            new MKF("Tr2InteriorLightSource", "coneDirection", Float3Reader),
            new MKF("Tr2InteriorLightSource", "falloff", FloatReader),
            new MKF("Tr2InteriorLightSource", "importanceBias", FloatReader),
            new MKF("Tr2InteriorLightSource", "importanceScale", FloatReader),
            new MKF("Tr2InteriorLightSource", "position", Float3Reader),
            new MKF("Tr2InteriorLightSource", "primaryLighting", BoolReader),
            new MKF("Tr2InteriorLightSource", "radius", FloatReader),
            new MKF("Tr2InteriorLightSource", "secondaryLighting", BoolReader),
            new MKF("Tr2InteriorLightSource", "secondaryLightingMultiplier", FloatReader),
            new MKF("Tr2InteriorLightSource", "shadowCasterTypes", Int32Reader),
            new MKF("Tr2InteriorLightSource", "shadowImportance", FloatReader),
            new MKF("Tr2InteriorLightSource", "shadowResolution", Int32Reader),
            new MKF("Tr2InteriorLightSource", "specularIntensity", FloatReader),
            new MKF("Tr2InteriorLightSource", "useKelvinColor", BoolReader),
            new MKF("Tr2InteriorParticleObject", "maxParticleRadius", FloatReader),
            new MKF("Tr2InteriorParticleObject", "shBoundsMax", Float3Reader),
            new MKF("Tr2InteriorParticleObject", "shBoundsMin", Float3Reader),
            new MKF("Tr2InteriorParticleObject", "transform", Matrix4x4Reader),
            new MKF("Tr2InteriorPlaceable", "transform", ObjectWithoutIndexReader),
            new MKF("Tr2InteriorScene", "shScale", FloatReader),
            new MKF("Tr2InteriorStatic", "displayTargetMesh", BoolReader),
            new MKF("Tr2InteriorStatic", "instanceInSystemIdx", Int32Reader),
            new MKF("Tr2InteriorStatic", "uvLinearTransform", Float4Reader),
            new MKF("Tr2InteriorStatic", "uvTranslation", Float2Reader),
            new MKF("Tr2IntSkinnedObject", "transform", ObjectWithoutIndexReader),
            new MKF("Tr2KelvinColor", "temperature", FloatReader),
            new MKF("Tr2KelvinColor", "tint", FloatReader),
            new MKF("Tr2MaterialMesh", "areas", DictionaryReader),
            new MKF("Tr2MaterialParameterStore", "parameters", DictionaryReader),
            new MKF("Tr2MaterialRes", "meshes", DictionaryReader),
            new MKF("Tr2Matrix4Parameter", "value", Matrix4x4Reader),
            new MKF("Tr2Mesh", "deferGeometryLoad", BoolReader),
            new MKF("Tr2Mesh", "isLowDetail", BoolReader),
            new MKF("Tr2Mesh", "meshIndex", Int32Reader),
            new MKF("Tr2MeshArea", "count", Int32Reader),
            new MKF("Tr2MeshArea", "index", Int32Reader),
            new MKF("Tr2MeshArea", "reversed", BoolReader),
            new MKF("Tr2MeshArea", "useSHLighting", BoolReader),
            new MKF("Tr2ParticleAttractorForce", "magnitude" , FloatReader),
            new MKF("Tr2ParticleDirectForce", "force", Float3Reader),
            new MKF("Tr2ParticleDragForce", "drag", FloatReader),
            new MKF("Tr2ParticleElementDeclaration", "dimension", Int32Reader),
            new MKF("Tr2ParticleElementDeclaration", "elementType", Int32Reader),
            new MKF("Tr2ParticleElementDeclaration", "type", Int32Reader),
            new MKF("Tr2ParticleElementDeclaration", "usageIndex", Int32Reader),
            new MKF("Tr2ParticleElementDeclaration", "usedByGPU", BoolReader),
            new MKF("Tr2ParticleFluidDragForce", "drag", FloatReader),
            new MKF("Tr2ParticleSpring", "springConstant", FloatReader),
            new MKF("Tr2ParticleSystem", "applyAging", BoolReader),
            new MKF("Tr2ParticleSystem", "maxParticleCount", Int32Reader),
            new MKF("Tr2ParticleSystem", "requiresSorting", BoolReader),
            new MKF("Tr2ParticleSystem", "updateBoundingBox", BoolReader),
            new MKF("Tr2ParticleSystem", "updateSimulation", BoolReader),
            new MKF("Tr2ParticleTurbulenceForce", "amplitude", Float3Reader),
            new MKF("Tr2ParticleTurbulenceForce", "frequency", Float4Reader),
            new MKF("Tr2ParticleTurbulenceForce", "noiseLevel", Int32Reader),
            new MKF("Tr2ParticleTurbulenceForce", "noiseRatio", FloatReader),
            new MKF("Tr2RandomUniformAttributeGenerator", "elementType", Int32Reader),
            new MKF("Tr2RandomIntegerAttributeGenerator", "maxRange", Float4Reader),
            new MKF("Tr2RandomUniformAttributeGenerator", "maxRange", Float4Reader),
            new MKF("Tr2RandomUniformAttributeGenerator", "minRange", Float4Reader),
            new MKF("Tr2RandomUniformAttributeGenerator", "type", Int32Reader),
            new MKF("Tr2ScalarCurve", "cycle", BoolReader),
            new MKF("Tr2ScalarCurve", "endTangent", FloatReader),
            new MKF("Tr2ScalarCurve", "endValue", FloatReader),
            new MKF("Tr2ScalarCurve", "interpolation", Int32Reader),
            new MKF("Tr2ScalarCurve", "length", FloatReader),
            new MKF("Tr2ScalarCurve", "startTangent", FloatReader),
            new MKF("Tr2ScalarCurve", "startValue", FloatReader),
            new MKF("Tr2ScalarExprCurve", "cycle", BoolReader),
            new MKF("Tr2ScalarExprCurve", "endValue", FloatReader),
            new MKF("Tr2ScalarExprCurve", "input1", FloatReader),
            new MKF("Tr2ScalarExprCurve", "input2", FloatReader),
            new MKF("Tr2ScalarExprCurve", "input3", FloatReader),
            new MKF("Tr2ScalarExprCurve", "input4", FloatReader),
            new MKF("Tr2ScalarExprCurve", "length", FloatReader),
            new MKF("Tr2ScalarExprCurve", "randomMax", FloatReader),
            new MKF("Tr2ScalarExprCurve", "randomMin", FloatReader),
            new MKF("Tr2ScalarExprCurve", "sourcePositionB", Float3Reader),
            new MKF("Tr2ScalarExprCurve", "startValue", FloatReader),
            new MKF("Tr2ScalarExprCurve", "updateDistance", BoolReader),
            new MKF("Tr2ScalarExprKey", "input1", FloatReader),
            new MKF("Tr2ScalarExprKey", "input2", FloatReader),
            new MKF("Tr2ScalarExprKey", "input3", FloatReader),
            new MKF("Tr2ScalarExprKey", "interpolation", Int32Reader),
            new MKF("Tr2ScalarExprKey", "left", FloatReader),
            new MKF("Tr2ScalarExprKey", "randomMax", FloatReader),
            new MKF("Tr2ScalarExprKey", "randomMin", FloatReader),
            new MKF("Tr2ScalarExprKey", "right", FloatReader),
            new MKF("Tr2ScalarExprKey", "time", FloatReader),
            new MKF("Tr2ScalarExprKey", "value", FloatReader),
            new MKF("Tr2ScalarKey", "interpolation", Int32Reader),
            new MKF("Tr2ScalarKey", "leftTangent", FloatReader),
            new MKF("Tr2ScalarKey", "rightTangent", FloatReader),
            new MKF("Tr2ScalarKey", "time", FloatReader),
            new MKF("Tr2ScalarKey", "value", FloatReader),
            new MKF("Tr2ShaderFloat2Desc", "defaultValue", Float2Reader),
            new MKF("Tr2ShaderFloat3Desc", "defaultValue", Float3Reader),
            new MKF("Tr2ShaderFloat3Desc", "isColor", BoolReader),
            new MKF("Tr2ShaderFloat4Desc", "defaultValue", Float4Reader),
            new MKF("Tr2ShaderFloat4Desc", "isColor", BoolReader),
            new MKF("Tr2ShaderFloatDesc", "defaultValue", FloatReader),
            new MKF("Tr2ShaderMaterial", "parameters", DictionaryReader),
            new MKF("Tr2ShaderPermuteTag", "precompileHint", Int32Reader),
            new MKF("Tr2ShaderPermuteTag", "tagBits", Int32Reader),
            new MKF("Tr2SphereShapeAttributeGenerator", "maxPhi", FloatReader),
            new MKF("Tr2SphereShapeAttributeGenerator", "maxRadius", FloatReader),
            new MKF("Tr2SphereShapeAttributeGenerator", "maxSpeed", FloatReader),
            new MKF("Tr2SphereShapeAttributeGenerator", "maxTheta", FloatReader),
            new MKF("Tr2SphereShapeAttributeGenerator", "minPhi", FloatReader),
            new MKF("Tr2SphereShapeAttributeGenerator", "minRadius", FloatReader),
            new MKF("Tr2SphereShapeAttributeGenerator", "minSpeed", FloatReader),
            new MKF("Tr2SphereShapeAttributeGenerator", "minTheta", FloatReader),
            new MKF("Tr2SphereShapeAttributeGenerator", "parentVelocityFactor", FloatReader),
            new MKF("Tr2SphereShapeAttributeGenerator", "position", Float3Reader),
            new MKF("Tr2SphereShapeAttributeGenerator", "rotation", Float4Reader),
            new MKF("Tr2StaticEmitter", "meshIndex", Int32Reader),
            new MKF("Tr2Vector2Parameter", "value", Float2Reader),
            new MKF("Tr2Vector3Curve", "cycle", BoolReader),
            new MKF("Tr2Vector3Curve", "endTangent", Float3Reader),
            new MKF("Tr2Vector3Curve", "endValue", Float3Reader),
            new MKF("Tr2Vector3Curve", "length", FloatReader),
            new MKF("Tr2Vector3Curve", "startTangent", Float3Reader),
            new MKF("Tr2Vector3Curve", "startValue", Float3Reader),
            new MKF("Tr2Vector3Curve", "interpolation", Int32Reader),
            new MKF("Tr2Vector3Key", "interpolation", Int32Reader),
            new MKF("Tr2Vector3Key", "leftTangent", Float3Reader),
            new MKF("Tr2Vector3Key", "rightTangent", Float3Reader),
            new MKF("Tr2Vector3Key", "time", FloatReader),
            new MKF("Tr2Vector3Key", "value", Float3Reader),
            new MKF("Tr2Vector3Parameter", "value", Float3Reader),
            new MKF("Tr2Vector4Parameter", "value", Float4Reader),
            new MKF("TriAniMaterial", "ambient", ObjectWithoutIndexReader),
            new MKF("TriAniMaterial", "diffuse", ObjectWithoutIndexReader),
            new MKF("TriAniMaterial", "emissive", ObjectWithoutIndexReader),
            new MKF("TriAniMaterial", "specular", ObjectWithoutIndexReader),
            new MKF("TriArea", "areaInfoID", Int32Reader),
            new MKF("TriArea", "name", NameUCReader),
            new MKF("TriColor", "a", FloatReader),
            new MKF("TriColor", "b", FloatReader),
            new MKF("TriColor", "g", FloatReader),
            new MKF("TriColor", "r", FloatReader),
            new MKF("TriColorCurve", "extrapolation", Int32Reader),
            new MKF("TriColorCurve", "length", FloatReader),
            new MKF("TriColorCurve", "start", Int64Reader),
            new MKF("TriColorCurve", "useHSV", BoolReader),
            new MKF("TriColorCurve", "value", ObjectWithoutIndexReader),
            new MKF("TriColorKey", "interpolation", Int32Reader),
            new MKF("TriColorKey", "left", ObjectWithoutIndexReader),
            new MKF("TriColorKey", "right", ObjectWithoutIndexReader),
            new MKF("TriColorKey", "time", FloatReader),
            new MKF("TriColorKey", "value", ObjectWithoutIndexReader),
            new MKF("TriColorSequencer", "operator_", Int32Reader),
            new MKF("TriColorSequencer", "value", ObjectWithoutIndexReader),
            new MKF("TriCurveSet", "playOnLoad", BoolReader),
            new MKF("TriCurveSet", "scale", FloatReader),
            new MKF("TriEventCurve", "extrapolation", Int32Reader),
            new MKF("TriEventKey", "time", FloatReader),
            new MKF("TriFloat", "value", FloatReader),
            new MKF("TriFloatParameter", "value", FloatReader),
            new MKF("TriLight", "ambient", ObjectWithoutIndexReader),
            new MKF("TriLight", "diffuse", ObjectWithoutIndexReader),
            new MKF("TriLight", "direction", ObjectWithoutIndexReader),
            new MKF("TriLight", "position", ObjectWithoutIndexReader),
            new MKF("TriLight", "specular", ObjectWithoutIndexReader),
            new MKF("TriMaterial", "ambient", ObjectWithoutIndexReader),
            new MKF("TriMaterial", "diffuse", ObjectWithoutIndexReader),
            new MKF("TriMaterial", "emissive", ObjectWithoutIndexReader),
            new MKF("TriMaterial", "name", NameUCReader),
            new MKF("TriMaterial", "specular", ObjectWithoutIndexReader),
            new MKF("TriMatrix", "_11", FloatReader),
            new MKF("TriMatrix", "_12", FloatReader),
            new MKF("TriMatrix", "_13", FloatReader),
            new MKF("TriMatrix", "_14", FloatReader),
            new MKF("TriMatrix", "_21", FloatReader),
            new MKF("TriMatrix", "_22", FloatReader),
            new MKF("TriMatrix", "_23", FloatReader),
            new MKF("TriMatrix", "_24", FloatReader),
            new MKF("TriMatrix", "_31", FloatReader),
            new MKF("TriMatrix", "_32", FloatReader),
            new MKF("TriMatrix", "_33", FloatReader),
            new MKF("TriMatrix", "_34", FloatReader),
            new MKF("TriMatrix", "_41", FloatReader),
            new MKF("TriMatrix", "_42", FloatReader),
            new MKF("TriMatrix", "_43", FloatReader),
            new MKF("TriMatrix", "_44", FloatReader),
            new MKF("TriModel", "name", NameUCReader),
            new MKF("TriModel", "vertices", NameUCReader),
            new MKF("TriModelEmitter", "accel", ObjectWithoutIndexReader),
            new MKF("TriModelEmitter", "birthBy", Int32Reader),
            new MKF("TriModelEmitter", "deathColor", ObjectWithoutIndexReader),
            new MKF("TriModelEmitter", "emissionCurve", ObjectWithoutIndexReader),
            new MKF("TriModelEmitter", "keepBirthScale", BoolReader),
            new MKF("TriModelEmitter", "maxAge", FloatReader),
            new MKF("TriModelEmitter", "maxColor0", ObjectWithoutIndexReader),
            new MKF("TriModelEmitter", "maxMass", FloatReader),
            new MKF("TriModelEmitter", "maxPhi", FloatReader),
            new MKF("TriModelEmitter", "maxRot0", FloatReader),
            new MKF("TriModelEmitter", "maxRotVel0", FloatReader),
            new MKF("TriModelEmitter", "maxSize0", FloatReader),
            new MKF("TriModelEmitter", "maxSizeT", FloatReader),
            new MKF("TriModelEmitter", "maxVel0", FloatReader),
            new MKF("TriModelEmitter", "minAge", FloatReader),
            new MKF("TriModelEmitter", "minColor0", ObjectWithoutIndexReader),
            new MKF("TriModelEmitter", "minDrag", FloatReader),
            new MKF("TriModelEmitter", "minMass", FloatReader),
            new MKF("TriModelEmitter", "minPhi", FloatReader),
            new MKF("TriModelEmitter", "minRotVel0", FloatReader),
            new MKF("TriModelEmitter", "minSize0", FloatReader),
            new MKF("TriModelEmitter", "minSizeT", FloatReader),
            new MKF("TriModelEmitter", "minVel0", FloatReader),
            new MKF("TriModelEmitter", "numModels", Int32Reader),
            new MKF("TriModelEmitter", "radius", FloatReader),
            new MKF("TriModelEmitter", "rotAccel", FloatReader),
            new MKF("TriModelEmitter", "scaleSlowsRotation", BoolReader),
            new MKF("TriModelEmitter", "start", Int64Reader),
            new MKF("TriModelEmitter", "time", Float2Reader),
            new MKF("TriNearestBoundingPoint", "boundingSize", ObjectWithoutIndexReader),
            new MKF("TriNearestBoundingPoint", "value", ObjectWithoutIndexReader),
            new MKF("TriObserverLocal", "front", Float3Reader),
            new MKF("TriParticleCloud", "cloudType", Int32Reader),
            new MKF("TriParticleCloud", "name", NameUCReader),
            new MKF("TriParticleCloud", "numConnections", Int32Reader),
            new MKF("TriParticleCloud", "numParticles", Int32Reader),
            new MKF("TriParticleEmitter", "accel", ObjectWithoutIndexReader),
            new MKF("TriParticleEmitter", "deathColor", ObjectWithoutIndexReader),
            new MKF("TriParticleEmitter", "emissionCurve", ObjectWithoutIndexReader),
            new MKF("TriParticleEmitter", "localAccel", BoolReader),
            new MKF("TriParticleEmitter", "maxAge", FloatReader),
            new MKF("TriParticleEmitter", "maxColor0", ObjectWithoutIndexReader),
            new MKF("TriParticleEmitter", "maxDrag", FloatReader),
            new MKF("TriParticleEmitter", "maxMass", FloatReader),
            new MKF("TriParticleEmitter", "maxPhi", FloatReader),
            new MKF("TriParticleEmitter", "maxPos0", FloatReader),
            new MKF("TriParticleEmitter", "maxRot0", FloatReader),
            new MKF("TriParticleEmitter", "maxRotVel0", FloatReader),
            new MKF("TriParticleEmitter", "maxSize0", FloatReader),
            new MKF("TriParticleEmitter", "maxSizeT", FloatReader),
            new MKF("TriParticleEmitter", "maxVel0", FloatReader),
            new MKF("TriParticleEmitter", "minAge", FloatReader),
            new MKF("TriParticleEmitter", "minColor0", ObjectWithoutIndexReader),
            new MKF("TriParticleEmitter", "minDrag", FloatReader),
            new MKF("TriParticleEmitter", "minMass", FloatReader),
            new MKF("TriParticleEmitter", "minPhi", FloatReader),
            new MKF("TriParticleEmitter", "minPos0", FloatReader),
            new MKF("TriParticleEmitter", "minRotVel0", FloatReader),
            new MKF("TriParticleEmitter", "minSize0", FloatReader),
            new MKF("TriParticleEmitter", "minSizeT", FloatReader),
            new MKF("TriParticleEmitter", "minVel0", FloatReader),
            new MKF("TriParticleEmitter", "numParticles", Int32Reader),
            new MKF("TriParticleEmitter", "radius", FloatReader),
            new MKF("TriParticleEmitter", "rotAccel", FloatReader),
            new MKF("TriParticleEmitter", "rotationCurve", ObjectWithoutIndexReader),
            new MKF("TriParticleEmitter", "sysVel", BoolReader),
            new MKF("TriParticleEmitter", "useWorldScale", BoolReader),
            new MKF("TriParticleEmitter", "uvFPS", FloatReader),
            new MKF("TriParticleEmitter", "VelocityFactor", FloatReader),
            new MKF("TriParticleEmitter", "VelocityStretch", BoolReader),
            new MKF("TriPass", "alphaFunc", ByteReader),
            new MKF("TriPass", "alphaRef", Int32Reader),
            new MKF("TriPass", "blendOp", ByteReader),
            new MKF("TriPass", "dstBlend", ByteReader),
            new MKF("TriPass", "materialSource", ByteReader),
            new MKF("TriPass", "name", NameUCReader),
            new MKF("TriPass", "srcBlend", ByteReader),
            new MKF("TriPerlinCurve", "alpha", FloatReader),
            new MKF("TriPerlinCurve", "beta", FloatReader),
            new MKF("TriPerlinCurve", "N", Int32Reader),
            new MKF("TriPerlinCurve", "offset", FloatReader),
            new MKF("TriPerlinCurve", "scale", FloatReader),
            new MKF("TriPerlinCurve", "speed", FloatReader),
            new MKF("TriPerlinCurve", "value", FloatReader),
            new MKF("TriQuaternion", "w", FloatReader),
            new MKF("TriQuaternion", "x", FloatReader),
            new MKF("TriQuaternion", "y", FloatReader),
            new MKF("TriQuaternion", "z", FloatReader),
            new MKF("TriQuaternionKey", "interpolation", Int32Reader),
            new MKF("TriQuaternionKey", "left", ObjectWithoutIndexReader),
            new MKF("TriQuaternionKey", "right", ObjectWithoutIndexReader),
            new MKF("TriQuaternionKey", "time", FloatReader),
            new MKF("TriQuaternionKey", "value", ObjectWithoutIndexReader),
            new MKF("TriQuaternionSequencer", "value", ObjectWithoutIndexReader),
            new MKF("TriRGBAScalarSequencer", "value", ObjectWithoutIndexReader),
            new MKF("TriRigidOrientation", "drag", FloatReader),
            new MKF("TriRigidOrientation", "I", FloatReader),
            new MKF("TriRigidOrientation", "value", ObjectWithoutIndexReader),
            new MKF("TriRotationCurve", "extrapolation", Int32Reader),
            new MKF("TriRotationCurve", "length", FloatReader),
            new MKF("TriRotationCurve", "start", Int64Reader),
            new MKF("TriRotationCurve", "value", ObjectWithoutIndexReader),
            new MKF("TriScalarCurve", "extrapolation", Int32Reader),
            new MKF("TriScalarCurve", "length", FloatReader),
            new MKF("TriScalarCurve", "start", Int64Reader),
            new MKF("TriScalarCurve", "value", FloatReader),
            new MKF("TriScalarDistanceCurve", "offset", FloatReader),
            new MKF("TriScalarDistanceCurve", "scale", FloatReader),
            new MKF("TriScalarDistanceCurve", "value", FloatReader),
            new MKF("TriScalarKey", "interpolation", Int32Reader),
            new MKF("TriScalarKey", "left", FloatReader),
            new MKF("TriScalarKey", "right", FloatReader),
            new MKF("TriScalarKey", "time", FloatReader),
            new MKF("TriScalarKey", "value", FloatReader),
            new MKF("TriScalarSequencer", "clamping", BoolReader),
            new MKF("TriScalarSequencer", "value", FloatReader),
            new MKF("TriScene", "ambientLight", ObjectWithoutIndexReader),
            new MKF("TriScene", "bgColor", ObjectWithoutIndexReader),
            new MKF("TriScene", "color0", ObjectWithoutIndexReader),
            new MKF("TriScene", "color1", ObjectWithoutIndexReader),
            new MKF("TriScene", "fogColor", ObjectWithoutIndexReader),
            new MKF("TriScene", "nebula", ObjectWithoutIndexReader),
            new MKF("TriScene", "pointStarfield", FloatReader),
            new MKF("TriScene", "rangeFogColor", ObjectWithoutIndexReader),
            new MKF("TriScene", "sunLight", ObjectWithoutIndexReader),
            new MKF("TriScene", "worldPosition", ObjectWithoutIndexReader),
            new MKF("TriShader", "cull", ByteReader),
            new MKF("TriShader", "depthBias", FloatReader),
            new MKF("TriShader", "name", NameUCReader),
            new MKF("TriShader", "opaque", BoolReader),
            new MKF("TriShader", "order", Int32Reader),
            new MKF("TriShader", "writeZ", BoolReader),
            new MKF("TriSineCurve", "offset", FloatReader),
            new MKF("TriSineCurve", "scale", FloatReader),
            new MKF("TriSineCurve", "speed", FloatReader),
            new MKF("TriSineCurve", "value", FloatReader),
            new MKF("TriSplTransform", "localTransform", ObjectWithoutIndexReader),
            new MKF("TriSplTransform", "rotation", ObjectWithoutIndexReader),
            new MKF("TriSplTransform", "scaling", ObjectWithoutIndexReader),
            new MKF("TriSplTransform", "translation", ObjectWithoutIndexReader),
            new MKF("TriTexture", "addressU", Int32Reader),
            new MKF("TriTexture", "addressV", Int32Reader),
            new MKF("TriTexture", "borderColor", ObjectWithoutIndexReader),
            new MKF("TriTexture", "name", NameUCReader),
            new MKF("TriTexture", "pixels", NameUCReader),
            new MKF("TriTexture", "rotation", ObjectWithoutIndexReader),
            new MKF("TriTexture", "rotationCenter", ObjectWithoutIndexReader),
            new MKF("TriTexture", "scaling", ObjectWithoutIndexReader),
            new MKF("TriTexture", "texCoordIndexFlags", Int32Reader),
            new MKF("TriTexture", "textureTransformFlags", Int32Reader),
            new MKF("TriTexture", "transformBase", Int32Reader),
            new MKF("TriTexture", "translation", ObjectWithoutIndexReader),
            new MKF("TriTexture", "useCurves", BoolReader),
            new MKF("TriTexture2DParameter", "addressUMode", Int32Reader),
            new MKF("TriTexture2DParameter", "addressVMode", Int32Reader),
            new MKF("TriTexture2DParameter", "addressWMode", Int32Reader),
            new MKF("TriTexture2DParameter", "filterMode", Int32Reader),
            new MKF("TriTexture2DParameter", "maxAnisotropy", Int32Reader),
            new MKF("TriTexture2DParameter", "maxMipLevel", Int32Reader),
            new MKF("TriTexture2DParameter", "mipFilterMode", Int32Reader),
            new MKF("TriTexture2DParameter", "mipmapLodBias", FloatReader),
            new MKF("TriTexture2DParameter", "resourcePath", NameUCReader),
            new MKF("TriTexture2DParameter", "Srgb", BoolReader),
            new MKF("TriTexture2DParameter", "useAllOverrides", BoolReader),
            new MKF("TriTextureCubeParameter", "resourcePath", NameUCReader),
            new MKF("TriTextureStage", "alphaArg1", Int32Reader),
            new MKF("TriTextureStage", "alphaOp", ByteReader),
            new MKF("TriTextureStage", "colorArg1", Int32Reader),
            new MKF("TriTextureStage", "colorArg2", Int32Reader),
            new MKF("TriTextureStage", "colorOp", ByteReader),
            new MKF("TriTextureStage", "customColor", ObjectWithoutIndexReader),
            new MKF("TriTextureStage", "display", BoolReader),
            new MKF("TriTextureStage", "materialSource", ByteReader),
            new MKF("TriTextureStage", "maxMipLevel", Int32Reader),
            new MKF("TriTextureStage", "mipFilter", BoolReader),
            new MKF("TriTextureStage", "mipMapLodBias", FloatReader),
            new MKF("TriTextureStage", "name", NameUCReader),
            new MKF("TriTextureStage", "textureSource", ByteReader),
            new MKF("TriTextureStage", "textureSourceIndex", Int32Reader),
            new MKF("TriTransform", "display", BoolReader),
            new MKF("TriTransform", "localTransform", ObjectWithoutIndexReader),
            new MKF("TriTransform", "name", NameUCReader),
            new MKF("TriTransform", "pickable", BoolReader),
            new MKF("TriTransform", "rotation", ObjectWithoutIndexReader),
            new MKF("TriTransform", "scaling", ObjectWithoutIndexReader),
            new MKF("TriTransform", "sorted", BoolReader),
            new MKF("TriTransform", "transformBase", Int32Reader),
            new MKF("TriTransform", "translation", ObjectWithoutIndexReader),
            new MKF("TriTransform", "useCurves", BoolReader),
            new MKF("TriTransformParameter", "rotation", Float4Reader),
            new MKF("TriTransformParameter", "rotationCenter", Float3Reader),
            new MKF("TriTransformParameter", "scaling", Float3Reader),
            new MKF("TriTransformParameter", "transformBase", Int32Reader),
            new MKF("TriTransformParameter", "translation", Float3Reader),
            new MKF("TriTransformParameter", "worldTransform", Matrix4x4Reader),
            new MKF("TriValueBinding", "offset", Float4Reader),
            new MKF("TriValueBinding", "scale", FloatReader),
            new MKF("TriVector", "w", FloatReader),
            new MKF("TriVector", "x", FloatReader),
            new MKF("TriVector", "y", FloatReader),
            new MKF("TriVector", "z", FloatReader),
            new MKF("TriVector4Parameter", "v1", FloatReader),
            new MKF("TriVector4Parameter", "v2", FloatReader),
            new MKF("TriVector4Parameter", "v3", FloatReader),
            new MKF("TriVector4Parameter", "v4", FloatReader),
            new MKF("TriVectorCurve", "extrapolation", Int32Reader),
            new MKF("TriVectorCurve", "length", FloatReader),
            new MKF("TriVectorCurve", "start", Int64Reader),
            new MKF("TriVectorCurve", "value", ObjectWithoutIndexReader),
            new MKF("TriVectorKey", "interpolation", Int32Reader),
            new MKF("TriVectorKey", "left", ObjectWithoutIndexReader),
            new MKF("TriVectorKey", "right", ObjectWithoutIndexReader),
            new MKF("TriVectorKey", "time", FloatReader),
            new MKF("TriVectorKey", "value", ObjectWithoutIndexReader),
            new MKF("TriVectorSequencer", "value", ObjectWithoutIndexReader),
            new MKF("TriXYZScalarSequencer", "value", ObjectWithoutIndexReader),
            new MKF("TriYPRSequencer", "value", ObjectWithoutIndexReader),
            new MKF("TriYPRSequencer", "YawPitchRoll", ObjectWithoutIndexReader),
            new MKF("WodPlaceableRes", "farFadeDistance", FloatReader),
            new MKF("WodPlaceableRes", "nearFadeDistance", FloatReader)
        }.ToDictionary(x=>x.Item1);

        Dictionary<string, object> dictionary = new Dictionary<string, object>();

        public int Count { get { return dictionary.Count; } }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            return dictionary.TryGetValue(binder.Name, out result);
        }

        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            dictionary[binder.Name] = value;
            return true;
        }

        public override IEnumerable<string> GetDynamicMemberNames()
        {
            return dictionary.Keys;
        }

        public override string ToString()
        {
            return this.Type;
        }
    }
}