public void BorrarModelo(TgcMesh modelo)
        {
            string[] grillas;
            string[] posicion;
            int x;
            int y;
            int z;

            grillas = modelo.UserProperties["gid"].Split('+');

            foreach (string grilla in grillas)
            {
                posicion = grilla.Split('.');
                x = Convert.ToInt32(posicion[0]);
                y = Convert.ToInt32(posicion[1]);
                z = Convert.ToInt32(posicion[2]);

                GrillaRegularNode nodo = grid[x, y, z];

                for (int i = 0; i < nodo.Models.Count; i++)
                {
                    if (nodo.Models[i] == modelo)
                        nodo.Models.RemoveAt(i);
                }
            }
        }

 public MeshTranslatedScaledPart(TgcMesh mesh, Vector3 translation, Vector3 scaleFactor)
     : base(mesh)
 {
     Position = _TranslationCurrent = Translation = translation;
     Scale = scaleFactor.MemberwiseMult(_ItemScale = Item.DefaultScale);
     ScaleFactor = scaleFactor;
 }

        /// <summary>
        /// Crear a partir de un mesh
        /// </summary>
        public static TgcTriangleArray fromMesh(TgcMesh mesh)
        {
            TgcTriangleArray triangleArray = new TgcTriangleArray();

            Vector3[] vertices = mesh.getVertexPositions();
            int triCount = vertices.Length / 3;
            List<TgcTriangle> triangles = new List<TgcTriangle>(triCount);
            for (int i = 0; i < triCount; i++)
            {
                Vector3 v1 = vertices[i * 3];
                Vector3 v2 = vertices[i * 3 + 1];
                Vector3 v3 = vertices[i * 3 + 2];

                TgcTriangle t = new TgcTriangle();
                t.A = v1;
                t.B = v2;
                t.C = v3;
                t.Color = Color.Red;
                t.updateValues();
                triangles.Add(t);
            }

            triangleArray.triangles.AddRange(triangles);
            return triangleArray;
        }

 /// <summary>
 /// Crear un modelo adjunto a un hueso
 /// </summary>
 /// <param name="model">Modelo a adjuntar</param>
 /// <param name="bone">Hueso al cual adjuntarse</param>
 /// <param name="offset">Offset desde el cual el modelo sigue al hueso</param>
 public TgcSkeletalBoneAttach(TgcMesh mesh, TgcSkeletalBone bone, Matrix offset)
 {
     this.bone = bone;
     this.mesh = mesh;
     this.offset = offset;
     updateValues();
 }

        public Ship(Vector3 pos, TgcMesh mesh, Canion canion)
        {
            Vector3 size = new Vector3(15, 10, 30);

            this.mesh = mesh;
            this.mesh.Position = pos;

            movZ = pos.Z;
            movY = pos.Y;
            movX = pos.X;
            traslacion = Matrix.Translation(pos);

            movementSpeed = 0f;

            this.mesh.AutoTransformEnable = false;

            vida = VIDA_MAX;

            timer = new TimerFinito(5);

            // Calcular dimensiones
            Vector3 BoundingBoxSize = mesh.BoundingBox.calculateSize();

            LargoBote = Math.Abs(BoundingBoxSize.Z);
            AnchoBote = Math.Abs(BoundingBoxSize.X);
            AltoBote = Math.Abs(BoundingBoxSize.Y);

            this.canion = canion;
            canion.barco = this;

            iniciarBarra();
        }

 public MeshTemporalRecursivePart(TgcMesh mesh, Int32 snapshots = 100)
     : base(mesh)
 {
     _Last = snapshots - 1;
     _Snapshots = new Matrix[snapshots];
     _DeltaAlpha = .666f / snapshots;
 }

 public Checkpoint(float x, float z, float y, TgcMesh _modelo)
 {
     _modelo.Position = new Vector3(x, y, z);
     this.modelo = _modelo;
     this.modelo.Scale = new Vector3(5, 5, 5);
     this.obb = TgcObb.computeFromAABB(this.modelo.BoundingBox);
 }

        public override void init()
        {
            Device d3dDevice = GuiController.Instance.D3dDevice;

            TgcSceneLoader loader = new TgcSceneLoader();
            TgcScene sceneOriginal = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Box\\" + "Box-TgcScene.xml");
            TgcMesh meshOriginal = sceneOriginal.Meshes[0];

            TgcMesh meshInstance1 = new TgcMesh(meshOriginal.Name + "-1", meshOriginal,
                new Vector3(50, 0, 0), meshOriginal.Rotation, meshOriginal.Scale);
            meshInstance1.Enabled = true;

            TgcMesh meshInstance2 = new TgcMesh(meshOriginal.Name + "-2", meshOriginal,
                new Vector3(100, 0, 0), meshOriginal.Rotation, meshOriginal.Scale);
            meshInstance2.Enabled = true;

            meshes = new List<TgcMesh>();
            meshes.Add(meshOriginal);
            meshes.Add(meshInstance1);
            meshes.Add(meshInstance2);

            TgcTexture texture = TgcTexture.createTexture(d3dDevice, GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Piso\\Textures\\piso2.jpg");
            meshOriginal.changeDiffuseMaps(new TgcTexture[] { texture });

            GuiController.Instance.FpsCamera.Enable = true;
        }

        public override void init()
        {
            Device d3dDevice = GuiController.Instance.D3dDevice;

            string sphere = GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Sphere\\Sphere-TgcScene.xml";

            TgcSceneLoader loader = new TgcSceneLoader();

            //Cargar modelos para el sol, la tierra y la luna. Son esfereas a las cuales le cambiamos la textura
            sun = loader.loadSceneFromFile(sphere).Meshes[0];
            sun.changeDiffuseMaps(new TgcTexture[] { TgcTexture.createTexture(d3dDevice, GuiController.Instance.ExamplesDir + "Transformations\\SistemaSolar\\SunTexture.jpg") });
            
            earth = loader.loadSceneFromFile(sphere).Meshes[0];
            earth.changeDiffuseMaps(new TgcTexture[] { TgcTexture.createTexture(d3dDevice, GuiController.Instance.ExamplesDir + "Transformations\\SistemaSolar\\EarthTexture.jpg") });
            
            moon = loader.loadSceneFromFile(sphere).Meshes[0];
            moon.changeDiffuseMaps(new TgcTexture[] { TgcTexture.createTexture(d3dDevice, GuiController.Instance.ExamplesDir + "Transformations\\SistemaSolar\\MoonTexture.jpg") });
            

            //Deshabilitamos el manejo automático de Transformaciones de TgcMesh, para poder manipularlas en forma customizada
            sun.AutoTransformEnable = false;
            earth.AutoTransformEnable = false;
            moon.AutoTransformEnable = false;


            //Color de fondo
            GuiController.Instance.BackgroundColor = Color.Black;


            //Camara en primera persona
            GuiController.Instance.FpsCamera.Enable = true;
            GuiController.Instance.FpsCamera.setCamera(new Vector3(705.2938f, 305.347f, -888.1567f), new Vector3(183.6915f, 19.6596f, -84.2204f));
        }

        public override void init()
        {
            Device d3dDevice = GuiController.Instance.D3dDevice;

            //Cargar mesh
            TgcSceneLoader loader = new TgcSceneLoader();
            mesh = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\LogoTGC\\LogoTGC-TgcScene.xml").Meshes[0];

            //Cargar Shader de PhongShading
            mesh.Effect = GuiController.Instance.Shaders.TgcMeshPhongShader;
            mesh.Technique = GuiController.Instance.Shaders.getTgcMeshTechnique(mesh.RenderType);

            //Texto help
            textHelp = new TgcText2d();
            textHelp.Position = new Point(15, 260);
            textHelp.Size = new Size(500, 100);
            textHelp.changeFont(new System.Drawing.Font("TimesNewRoman", 16, FontStyle.Regular));
            textHelp.Color = Color.Yellow;
            textHelp.Align = TgcText2d.TextAlign.LEFT;
            textHelp.Text = "¿Por dónde empezar? Presionar \"H\"";

            //Help form
            string helpRtf = File.ReadAllText(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\LogoTGC\\help.rtf");
            helpForm = new EjemploDefaultHelpForm(helpRtf);

            //Camara
            GuiController.Instance.RotCamera.Enable = true;
            GuiController.Instance.RotCamera.CameraCenter = new Vector3(0, 0, 0);
            GuiController.Instance.RotCamera.CameraDistance = 150;

            GuiController.Instance.BackgroundColor = Color.Black;
        }

        protected TgcMesh instanceOf(TgcMesh m)
        {
            TgcMesh i = m.createMeshInstance(m.Name+m.MeshInstances.Count.ToString());
            i.AlphaBlendEnable = m.AlphaBlendEnable;
            return i;

        }

 public MeshTransformedPart(TgcMesh mesh)
     : base(mesh)
 {
     Scale = Item.DefaultScale;
     Rotation = Item.DefaultRotation;
     Position = Item.DefaultPosition;
     RotationMatrix = Item.DefaultRotationMatrix;
 }

 public MeshPart(TgcMesh mesh)
 {
     Mesh = mesh;
     mesh.AlphaBlendEnable = true;
     mesh.AutoTransformEnable = false;
     mesh.AutoUpdateBoundingBox = false;
     _Technique = mesh.Technique;
 }

 public EnemyShip(Ship player, Vector3 pos, TgcMesh mesh, Canion canion)
     : base(pos, mesh, canion)
 {
     nombre = "ENEMIGO";
     this.player = player;
     anguloRotacion = FastMath.PI / 2;
     iniciarBarra();
 }

 public BarcoBot(int vida, int danio, float velocidad,float aceleracion, float rotacion, TgcMesh mesh, double pot, Barco barcoEnemigo,TgcSceneLoader bm,TgcMesh bala)
     : base(vida, danio, velocidad, rotacion, mesh,pot,bm,bala)
 {
     BarcoEnemigo = barcoEnemigo;
     LastPos = Mesh.Position;
     BarcosEnemigos.Add(barcoEnemigo);
     daniado = false;
 }

 public static TgcMesh getMesh()
 {
     if (originalMesh == null)
     {
         TgcScene sceneBarril = EscenarioManager.Instance.loader.loadSceneFromFile(GuiController.Instance.AlumnoEjemplosMediaDir + "RenderMan\\modelos\\BarrilPolvora\\BarrilPolvora-TgcScene.xml");
         TgcMesh barrilMesh = sceneBarril.Meshes[0];
         originalMesh = barrilMesh;
     }
     return originalMesh.createMeshInstance("barril");
 }

 /// <summary>
 /// Construir un EditablePoly a partir de un mesh
 /// </summary>
 public EditablePoly(MeshCreatorControl control, TgcMesh origMesh)
 {
     this.control = control;
     this.currentPrimitive = PrimitiveType.None;
     this.rectMesh = new SelectionRectangleMesh();
     this.selectionList = new List<EditPolyPrimitive>();
     this.primitiveRenderer = new PrimitiveRenderer(this);
     this.translateGizmo = new EditablePolyTranslateGizmo(this);
     this.deletedTriangles = new List<int>();
     loadMesh(origMesh);
 }

        public TgcRTLMesh(TgcMesh parent, Color ambientColor, Color diffuseColor, Color specularColor, float shininess)
            : base(parent.Name, parent, parent.Position, parent.Rotation, parent.Scale)
        {
            this.Enabled = true;

            material.Ambient = ambientColor;
            material.Diffuse = diffuseColor;
            material.Specular = specularColor;
            material.SpecularSharpness = shininess;

            //TODO: Autoinicializar el efecto
        }

        public void mover(LightData luz, TgcMesh meshLuz, float elapsedTime)
        {
            Matrix directionRotationMatrix = Matrix.RotationX(FastMath.QUARTER_PI * elapsedTime);
            luz.direccion.TransformCoordinate(directionRotationMatrix);

            Matrix trans = Matrix.Translation(meshLuz.Position);
            Matrix trasp = Matrix.Invert(trans);

            meshLuz.Transform = Matrix.Multiply(trasp, directionRotationMatrix) * trans * meshLuz.Transform;

            meshLuz.render();
        }

 public Chispa()
 {
     TgcSceneLoader loader = new TgcSceneLoader();
     mesh = loader.loadSceneFromFile(sphere).Meshes[0];
     mesh.changeDiffuseMaps(new TgcTexture[] { TgcTexture.createTexture(d3dDevice, Shared.mediaPath + "\\otros\\giallo.png") });
     mesh.Scale = new Vector3(0.08f, 0.08f, 0.08f);
 }