Esempio n. 1
0
        private void addTrees()
        {
            var pino = GetMeshFromScene("Pino-TgcScene.xml");

            pino.AlphaBlendEnable = false;//no se porque lo tenia seteado en true

            for (int j = 1; j < Chunks.chunksPerDim - 1; j++)
            {
                for (int k = 1; k < Chunks.chunksPerDim - 1; k++)
                {
                    if (coordsOccupied(j, k))
                    {
                        continue;
                    }

                    for (var i = 0; i < treesPerChunk; i++)
                    {
                        Meshc meshc = new Meshc();
                        meshc.mesh = pino;
                        meshc.type = 1;

                        TGCVector3 pos = genPosInChunk(j, k);

                        var scale = TGCVector3.One * Random.Next(20, 500);

                        meshc.originalMesh = TGCMatrix.Scaling(scale) * TGCMatrix.Translation(pos);

                        var box  = meshc.mesh.BoundingBox;
                        var size = box.calculateSize();
                        var posb = box.calculateBoxCenter();

                        size.X *= .1f;
                        size.Z *= .1f;

                        posb.X -= size.X * .2f;

                        meshc.paralleliped = Parallelepiped.fromSizePosition(
                            size,
                            posb
                            );


                        meshc.deformation     = new TGCMatrix();
                        meshc.deformation.M11 = (float)Random.NextDouble() * 2f - 1f;
                        meshc.deformation.M12 = (float)Random.NextDouble() * 2f - 1f;
                        meshc.deformation.M13 = (float)Random.NextDouble() * 2f - 1f;
                        meshc.deformation.M21 = (float)Random.NextDouble() * 2f - 1f;
                        meshc.deformation.M22 = (float)Random.NextDouble() * 2f - 1f;
                        meshc.deformation.M23 = (float)Random.NextDouble() * 2f - 1f;
                        meshc.deformation.M31 = (float)Random.NextDouble() * 2f - 1f;
                        meshc.deformation.M32 = (float)Random.NextDouble() * 2f - 1f;
                        meshc.deformation.M33 = (float)Random.NextDouble() * 2f - 1f;
                        meshc.deformation.M42 = -1.4f;

                        meshc.deform();
                    }
                }
            }
        }
Esempio n. 2
0
        public void addCandles()
        {
            candleMesh = GetMeshFromScene("Vela-TgcScene.xml");
            //candleMesh.Effect = shader;
            //candleMesh.Technique = "DIFFUSE_MAP";
            for (int i = 0; i < g.cameraSprites.candlesInMap; i++)
            {
                int j, k;
                do
                {
                    j = Random.Next(1, Chunks.chunksPerDim - 1);
                    k = Random.Next(1, Chunks.chunksPerDim - 1);

                    var pos = genPosInChunk(j, k);
                    pos.Y += 200f;

                    if (checkColission(pos, 700f))
                    {
                        continue;
                    }

                    var candleMeshc = new Meshc();
                    //un poco excesivo que sea un meshc, lo eficiente seria que vela sea un tipo propio con una colision
                    //por radio. Pero hacer eso hace agregar un nuevo tipo de meshc, lo que podria hacer el codigo mas lento
                    //si sigo el camino de no usar polimorfismo. Igual ni ganas de agregar otro tipo. Que sea un meshc tiene
                    //los beneficios de que se va a poder deformar, y estas colisiones van a evitar que las velas se superpongan
                    //aunque agregar codigo para que se haga eso tampoco es una locura

                    candleMeshc.mesh         = candleMesh;
                    candleMeshc.originalMesh = TGCMatrix.Scaling(new TGCVector3(10, 15, 10)) * TGCMatrix.Translation(pos);

                    var box  = candleMeshc.mesh.BoundingBox;
                    var size = box.calculateSize();
                    var posb = box.calculateBoxCenter();

                    size.X *= 2.5f;
                    size.Y *= 10f;
                    size.Z *= 2.5f; //estaria bueno que tgc tenga multiplicacion miembro a miembro

                    candleMeshc.paralleliped = Parallelepiped.fromSizePosition(
                        size,
                        posb
                        );

                    //no uso  transformColission porque hace caer 4 vertices, lo que tiene potencial de registrar la
                    //vela en mas de un chunk
                    candleMeshc.paralleliped.transform(candleMeshc.originalMesh);
                    Chunk c = g.chunks.fromCoordinates(candleMeshc.paralleliped.transformedVertex[0]);
                    if (c != null)
                    {
                        c.meshes.Add(candleMeshc);
                    }

                    break;
                } while (true);
            }
        }