/// <summary>
        /// Adds all of the geometry used by a model component to the static geometry.
        /// This is used by the ModelComponent.
        /// </summary>
        public void Add(ModelComponent mc, ThingBlock template, ModelBlock block, ThingDefinition def)
        {
            // if the model detail option is low and this model wants imposters, don't even make any static geometry of it
            if (Options.ModelDetail == ModelDetailOption.Low) {
                if (def.GetBoolProperty("Imposters", false))
                    return;
            }

            var sceneMgr = LKernel.GetG<SceneManager>();

            string meshName = block.GetStringProperty("mesh", null);
            // map region goes first
            string sgeomName = template.GetStringProperty("MapRegion", "(Default)");
            // static group can override map region
            sgeomName = block.GetStringProperty("StaticGroup", sgeomName);
            Entity ent;

            // get our entity if it already exists
            if (!ents.TryGetValue(meshName, out ent)) {
                // getting the entity was not successful, so we have to create it
                ent = sceneMgr.CreateEntity(meshName + mc.ID, meshName);
                string material;
                if (block.StringTokens.TryGetValue("material", out material))
                    ent.SetMaterialName(material);

                ents.Add(meshName, ent);
            }

            Vector3 pos;
            // two ways to get the position
            // inherit it from the lthing, the default (if we were using nodes, this would be the default too)
            if (block.GetBoolProperty("InheritOrientation", true)) {
                pos = (mc.Owner.SpawnOrientation * block.GetVectorProperty("position", Vector3.ZERO)) + template.VectorTokens["position"];
            }
            // or we can choose not to inherit it for whatever reason
            else {
                pos = block.GetVectorProperty("position", Vector3.ZERO) + template.VectorTokens["position"];
            }
            Quaternion orient = block.GetQuatProperty("orientation", Quaternion.IDENTITY) * template.GetQuatProperty("orientation", Quaternion.IDENTITY);
            Vector3 sca = block.GetVectorProperty("scale", Vector3.UNIT_SCALE);

            StaticGeometry sg;
            if (!sgeoms.TryGetValue(sgeomName, out sg)) {
                sg = LKernel.GetG<SceneManager>().CreateStaticGeometry(sgeomName);

                sg.RegionDimensions = regionDimensions;
                sg.RenderingDistance = 300 / 5f;

                sgeoms.Add(sgeomName, sg);
            }

            sg.AddEntity(ent, pos, orient, sca);
        }
        public void Add(ModelComponent mc, ThingBlock template, ModelBlock block, ThingDefinition def)
        {
            // if the model detail option is low and this model wants imposters, don't even make any instanced geometry of it
            if (Options.ModelDetail == ModelDetailOption.Low) {
                if (def.GetBoolProperty("Imposters", false))
                    return;
            }

            var sceneMgr = LKernel.GetG<SceneManager>();

            string meshName = block.GetStringProperty("mesh", null);
            string mapRegion = template.GetStringProperty("MapRegion", string.Empty);
            string key = mapRegion + meshName;

            // create our entity if it doesn't exist
            if (!ents.ContainsKey(key)) {
                Entity ent = sceneMgr.CreateEntity(mc.Name + mc.ID, meshName);
                ent.SetMaterialName(block.GetStringProperty("Material", string.Empty));
                // then add it to our dictionary
                ents.Add(key, ent);
            }

            // get our transforms
            Vector3 pos;
            // two ways to get the position
            // inherit it from the lthing, the default (if we were using nodes, this would be the default too)
            if (block.GetBoolProperty("InheritOrientation", true)) {
                pos = (mc.Owner.SpawnOrientation * block.GetVectorProperty("position", Vector3.ZERO)) + template.VectorTokens["position"];
            }
            // or we can choose not to inherit it for whatever reason
            else {
                pos = block.GetVectorProperty("position", Vector3.ZERO) + template.VectorTokens["position"];
            }
            Quaternion orient = block.GetQuatProperty("orientation", Quaternion.IDENTITY) * template.GetQuatProperty("orientation", Quaternion.IDENTITY);
            Vector3 sca = block.GetVectorProperty("scale", Vector3.UNIT_SCALE);

            // put them in one class
            Transform trans = new Transform {
                Position = pos,
                Orientation = orient,
                Scale = sca,
            };

            // if the transforms dictionary doesn't contain the mesh yet, add a new one
            if (!transforms.ContainsKey(key)) {
                transforms.Add(key, new List<Transform>());
            }
            // then put our transform into the dictionary
            transforms[key].Add(trans);
        }
        /// <summary>
        /// Creates a model component for a Thing.
        /// </summary>
        /// <param name="lthing">The Thing this component is attached to</param>
        /// <param name="template">The template from the Thing</param>
        /// <param name="block">The block we're creating this component from</param>
        public ModelComponent(LThing lthing, ThingBlock template, ModelBlock block, ThingDefinition def)
        {
            ID = IDs.Incremental;
            Owner = lthing;
            var sceneMgr = LKernel.GetG<SceneManager>();

            Name = block.GetStringProperty("name", template.ThingName);

            // set these up here because static/instanced geometry might need them
            // position
            SpawnPosition = block.GetVectorProperty("position", Vector3.ZERO);

            // orientation
            SpawnOrientation = block.GetQuatProperty("orientation", Quaternion.IDENTITY);
            // if orientation was not found, we fall back to rotation
            if (SpawnOrientation == Quaternion.IDENTITY) {
                Vector3 rot = block.GetVectorProperty("rotation", Vector3.ZERO);
                if (rot != Vector3.ZERO)
                    SpawnOrientation = rot.DegreeVectorToGlobalQuaternion();
            }
            // scale
            SpawnScale = block.GetVectorProperty("scale", Vector3.UNIT_SCALE);

            ThingEnum shad = block.GetEnumProperty("CastsShadows", ThingEnum.Some);
            // if we're static, set up the static geometry
            // don't set up static geometry if we want to cast shadows though, since static geometry doesn't work with shadows
            if ((block.GetBoolProperty("static", false) || def.GetBoolProperty("static", false))
                // make static if we never want shadows
                && (shad == ThingEnum.None
                // or if the mesh has "some" shadows but we don't want any
                    || (shad == ThingEnum.Some && Options.ShadowDetail == ShadowDetailOption.None)
                // or if the mesh has "many" shadows but we only want those with "some"
                    || (shad == ThingEnum.Many && Options.ShadowDetail != ShadowDetailOption.Many)))
            {
                LKernel.GetG<StaticGeometryManager>().Add(this, template, block, def);
                Entity = null;
            }
            else if (block.GetBoolProperty("instanced", false) || def.GetBoolProperty("instanced", false)) {
                LKernel.GetG<InstancedGeometryManager>().Add(this, template, block, def);
                Entity = null;
            }
            // for attachments
            else if (block.GetBoolProperty("Attached", false)) {
                SetupEntity(sceneMgr, block);
                SetupAnimation(block);

                string boneName = block.GetStringProperty("AttachBone", null);
                int modelComponentID = (int) block.GetFloatProperty("AttachComponentID", null);
                Quaternion offsetQuat = block.GetQuatProperty("AttachOffsetOrientation", Quaternion.IDENTITY);
                Vector3 offsetVec = block.GetVectorProperty("AttachOffsetPosition", Vector3.ZERO);

                lthing.ModelComponents[modelComponentID].Entity.AttachObjectToBone(boneName, Entity, offsetQuat, offsetVec);
            }
            // otherwise continue as normal
            else {
                Node = lthing.RootNode.CreateChildSceneNode(Name + "Node" + ID);

                Node.Position = SpawnPosition;
                Node.Orientation = SpawnOrientation;
                Node.Scale(SpawnScale);

                Node.InheritScale = block.GetBoolProperty("InheritScale", true);
                Node.InheritOrientation = block.GetBoolProperty("InheritOrientation", true);
                Node.SetInitialState();

                // make our entity
                SetupEntity(sceneMgr, block);

                SetupAnimation(block);

                // then attach it to the node!
                Node.AttachObject(Entity);
            }
        }