Beispiel #1
0
        public void addVertexFall(Parallelepiped par, MultiMeshc meshc)
        {
            Action <TGCVector3> addToChunk = v =>
            {
                Chunk c = fromCoordinates(v);
                if (c != null)
                {
                    if (!c.multimeshes.Contains(meshc))
                    {
                        c.multimeshes.Add(meshc);
                        c.parallelepipedsOfMultimesh.Add(par);
                    }
                    else
                    {
                        if (!c.parallelepipedsOfMultimesh.Contains(par))
                        {
                            c.parallelepipedsOfMultimesh.Add(par);
                        }
                    }
                }
            };

            foreach (TGCVector3 vertex in par.transformedVertex)
            {
                addToChunk(vertex);
            }

            Action <int, int, float> extraVertex = (v1, v2, w1) =>
            {
                float w2     = 1f - w1;
                var   vertex = new TGCVector3(par.transformedVertex[v1].X * w1 + par.transformedVertex[v2].X * w2,
                                              0,
                                              par.transformedVertex[v1].Z * w1 + par.transformedVertex[v2].Z * w2);
                addToChunk(vertex);
            };

            extraVertex(0, 4, .5f);
            extraVertex(0, 1, .5f);
            extraVertex(1, 5, .5f);
            extraVertex(4, 5, .5f);//@optim puede que tirar vertex del piso no sea necesario, ver al final

            extraVertex(2, 6, .5f);
            extraVertex(2, 3, .5f);
            extraVertex(3, 7, .5f);
            extraVertex(6, 7, .5f);

            extraVertex(2, 7, .5f);
            extraVertex(2, 7, .25f);
            extraVertex(2, 7, .75f);

            extraVertex(4, 1, .5f);
            extraVertex(4, 1, .25f);
            extraVertex(4, 1, .75f);
        }
Beispiel #2
0
        void addChurch()
        {
            var loader = new TgcSceneLoader();
            var scene  = loader.loadSceneFromFile(g.game.MediaDir + "church-TgcScene.xml");

            var mm = new MultiMeshc();

            mm.originalMesh = TGCMatrix.Translation(0, -160, 0)
                              * TGCMatrix.Scaling(75, 75, 75);

            int cantBoxes = 0;

            foreach (var m in scene.Meshes)
            {
                if (m.Name.StartsWith("Box"))
                {
                    cantBoxes++;
                }
            }
            const int putByHand = 7;

            mm.meshes        = new TgcMesh[scene.Meshes.Count - cantBoxes];
            mm.parallelipeds = new Parallelepiped[cantBoxes + putByHand];

            int meshIndex = 0;
            int parIndex  = 0;

            foreach (var m in scene.Meshes)
            {
                if (m.Name.StartsWith("Box"))
                {
                    var par = Parallelepiped.fromBounding(m.BoundingBox);
                    mm.parallelipeds[parIndex++] = par;
                    par.transform(mm.originalMesh);
                    g.chunks.addVertexFall(par, mm);
                }
                else
                {
                    m.AutoTransformEnable  = false;
                    mm.meshes[meshIndex++] = m;
                }
            }

            //---
            //+--
            //-+-
            //++-
            //--+
            //+-+
            //-++
            //+++

            //techito
            mm.parallelipeds[parIndex++] = Parallelepiped.fromVertex(
                1, 472, -257,
                66, 413, -257,
                1, 430, -257,
                32, 413, -257,
                1, 472, -214,
                66, 413, -214,
                1, 430, -214,
                32, 413, -214

                );
            mm.parallelipeds[parIndex++] = Parallelepiped.fromVertex(
                -62, 414, -257,
                -29, 414, -257,
                1, 469, -257,
                1, 430, -257,
                -62, 414, -213,
                -29, 414, -213,
                1, 469, -213,
                1, 430, -213
                );

            //bordes
            mm.parallelipeds[parIndex++] = Parallelepiped.fromVertex(
                -93, 279, -257,
                -58, 279, -257,
                -58, 327, -257,
                -58.5f, 327.5f, -257,
                -93, 279, -213,
                -58, 279, -213,
                -58, 327, -213,
                -58.5f, 327.5f, -213
                );
            mm.parallelipeds[parIndex++] = Parallelepiped.fromVertex(
                95, 279, -257,
                69, 279, -257,
                69, 317, -257,
                69.5f, 317.5f, -257,
                95, 279, -213,
                69, 279, -213,
                69, 317, -213,
                69.5f, 317.5f, -213
                );

            //fondo
            mm.parallelipeds[parIndex++] = Parallelepiped.fromVertex(
                166, 230, 260,
                -163, 230, 260,
                0, 332, 260,
                0.5f, 332.5f, 260,
                166, 230, 239,
                -163, 230, 239,
                0, 332, 239,
                0.5f, 332.5f, 239
                );


            //techo
            mm.parallelipeds[parIndex++] = Parallelepiped.fromVertex(
                172, 227, 264,
                0, 227f, 264,
                172, 231, 264,
                0, 341, 264,
                172, 227, -217,
                0, 227f, -217,
                172, 231, -217,
                0, 341, -217
                );
            mm.parallelipeds[parIndex++] = Parallelepiped.fromVertex(
                -172, 227, 264,
                0, 227f, 264,
                -172, 231, 264,
                0, 341, 264,
                -172, 227, -217,
                0, 227f, -217,
                -172, 231, -217,
                0, 341, -217
                );//puede que el que tenga forma de triangulo cause problemas con alguna deformacion por los
                  //vertex fall, pero por ahora no parece haber problema


            mm.deformation     = new TGCMatrix();
            mm.deformation.M21 = 1;
            mm.deformation.M22 = 1.5f;

            for (int i = cantBoxes; i < cantBoxes + putByHand; i++)
            {
                var par = mm.parallelipeds[i];
                par.transform(mm.originalMesh);
                g.chunks.addVertexFall(par, mm);
            }

            /*
             * //partes de la iglesia no caen en ningun vertex, las agrego manualmente
             * var addToChunk = new Action<TGCVector3>(v => {
             *  var c = g.chunks.fromCoordinates(v);
             *  if (!c.multimeshes.Contains(mm))
             *  {
             *      c.multimeshes.Add(mm);
             *  }
             * });
             *
             * addToChunk(new TGCVector3(-7168f, 0, 18671f));
             * addToChunk(new TGCVector3(124, 0, -345));
             * addToChunk(new TGCVector3(-1991, 0, -8930));
             * addToChunk(new TGCVector3(-3159, 0, 3621));
             * addToChunk(new TGCVector3(2258, 0, 3767));
             *
             * //centro de la iglesia ( -2879,753   -10917,6   3882,9  )
             */

            mm.type = 0;
        }