Path3F.Add C# (CSharp) Exemples de code

Exemple #1

0

Afficher le fichier

        // Add a random path.
        private void CreateRandomPath()
        {
            var path  = new Path3F();
            var point = new Vector3F(0, 0, 0);

            path.Add(new PathKey3F
            {
                Interpolation = SplineInterpolation.CatmullRom,
                Parameter     = 0,
                Point         = point
            });
            for (int i = 1; i < 10; i++)
            {
                point += RandomHelper.Random.NextQuaternionF().Rotate(new Vector3F(0, 0.5f, 0));
                path.Add(new PathKey3F
                {
                    Interpolation = SplineInterpolation.CatmullRom,
                    Parameter     = i,
                    Point         = point
                });
            }
            var pathFigure = new PathFigure3F();

            pathFigure.Segments.Add(path);

            var pathLineNode = new FigureNode(pathFigure)
            {
                Name              = "RandomPath",
                PoseLocal         = new Pose(new Vector3F(4, 1, 2)),
                StrokeThickness   = 3,
                StrokeColor       = new Vector3F(0.5f, 0.3f, 1),
                StrokeAlpha       = 1f,
                DashInWorldSpace  = true,
                StrokeDashPattern = new Vector4F(10, 1, 1, 1) / 100,
            };

            _scene.Children.Add(pathLineNode);
        }

Exemple #2

0

Afficher le fichier

Fichier : PiecewiseCurveTest.cs Projet : DireAussie/MinimalRune

        private Path3F CreatePath()
        {
            Path3F path = new Path3F();

            path.Add(new PathKey3F()
            {
                Parameter     = 10,
                Point         = new Vector3(1, 2, 3),
                Interpolation = SplineInterpolation.StepLeft,
                TangentIn     = new Vector3(1, 0, 0),
                TangentOut    = new Vector3(1, 0, 0),
            });
            path.Add(new PathKey3F()
            {
                Parameter     = 15,
                Point         = new Vector3(4, 5, 7),
                Interpolation = SplineInterpolation.StepCentered,
                TangentIn     = new Vector3(1, 0, 0),
                TangentOut    = new Vector3(1, 0, 0),
            });
            path.Add(new PathKey3F()
            {
                Parameter     = 18,
                Point         = new Vector3(5, 7, 10),
                Interpolation = SplineInterpolation.StepRight,
                TangentIn     = new Vector3(1, 0, 0),
                TangentOut    = new Vector3(1, 0, 0),
            });
            path.Add(new PathKey3F()
            {
                Parameter     = 20,
                Point         = new Vector3(5, 7, 13),
                Interpolation = SplineInterpolation.Linear,
                TangentIn     = new Vector3(1, 0, 0),
                TangentOut    = new Vector3(1, 0, 0),
            });
            path.Add(new PathKey3F()
            {
                Parameter     = 25,
                Point         = new Vector3(6, 7, 14),
                Interpolation = SplineInterpolation.Bezier,
                TangentIn     = new Vector3(5, 6, 13),
                TangentOut    = new Vector3(7, 8, 15),
            });
            path.Add(new PathKey3F()
            {
                Parameter     = 31,
                Point         = new Vector3(8, 10, 16),
                Interpolation = SplineInterpolation.BSpline,
                TangentIn     = new Vector3(1, 0, 0),
                TangentOut    = new Vector3(1, 0, 0),
            });
            path.Add(new PathKey3F()
            {
                Parameter     = 35,
                Point         = new Vector3(10, 12, 14),
                Interpolation = SplineInterpolation.Hermite,
                TangentIn     = new Vector3(1, 0, 0),
                TangentOut    = new Vector3(1, 0, 0),
            });
            path.Add(new PathKey3F()
            {
                Parameter     = 40,
                Point         = new Vector3(10, 14, 8),
                Interpolation = SplineInterpolation.CatmullRom,
                TangentIn     = new Vector3(1, 0, 0),
                TangentOut    = new Vector3(1, 0, 0),
            });
            return(path);
        }

Exemple #3

0

Afficher le fichier

        private void CreatePath()
        {
            // Create a cyclic path. (More information on paths can be found in the DigitalRune
            // Mathematics documentation and related samples.)
            _path = new Path3F
            {
                SmoothEnds = true,
                PreLoop    = CurveLoopType.Cycle,
                PostLoop   = CurveLoopType.Cycle
            };

            // The curvature of the path is defined by a number of path keys.
            _path.Add(new PathKey3F
            {
                Parameter     = 0,                              // The path parameter defines position of the path key on the curve.
                Point         = new Vector3(-4, 0.5f, -3),      // The world space position of the path key.
                Interpolation = SplineInterpolation.CatmullRom, // The type of interpolation that is used between this path key and the next.
            });
            _path.Add(new PathKey3F
            {
                Parameter     = 1,
                Point         = new Vector3(-1, 0.5f, -5),
                Interpolation = SplineInterpolation.CatmullRom,
            });
            _path.Add(new PathKey3F
            {
                Parameter     = 2,
                Point         = new Vector3(3, 0.5f, -4),
                Interpolation = SplineInterpolation.CatmullRom,
            });
            _path.Add(new PathKey3F
            {
                Parameter     = 3,
                Point         = new Vector3(0, 0.5f, 0),
                Interpolation = SplineInterpolation.CatmullRom,
            });
            _path.Add(new PathKey3F
            {
                Parameter     = 4,
                Point         = new Vector3(-3, 0.5f, 3),
                Interpolation = SplineInterpolation.CatmullRom,
            });
            _path.Add(new PathKey3F
            {
                Parameter     = 5,
                Point         = new Vector3(-1, 0.5f, 5),
                Interpolation = SplineInterpolation.CatmullRom,
            });
            _path.Add(new PathKey3F
            {
                Parameter     = 6,
                Point         = new Vector3(0, 0.5f, 0),
                Interpolation = SplineInterpolation.CatmullRom,
            });

            // The last key uses the same position as the first key to create a closed path.
            PathKey3F lastKey = new PathKey3F
            {
                Parameter     = _path.Count,
                Point         = _path[0].Point,
                Interpolation = SplineInterpolation.CatmullRom,
            };

            _path.Add(lastKey);

            // The current path parameter goes from 0 to 7. This path parameter is not linearly
            // proportional to the path length. This is not suitable for animations.
            // To move an object with constant speed along a path, the path parameter should
            // be linearly proportional to the length of the path.
            // ParameterizeByLength() changes the path parameter so that the path parameter
            // at the each key is equal to the length of path (measured from the first key position
            // to the current key position).
            // ParameterizeByLength() uses an iterative process, we end the process after 10
            // iterations or when the error is less than 0.01f.
            _path.ParameterizeByLength(10, 0.01f);

            // Sample the path for rendering.
            int   numberOfSamples = _pointList.Length - 1;
            float pathLength      = _path.Last().Parameter;

            for (int i = 0; i <= numberOfSamples; i++)
            {
                Vector3 pointOnPath = _path.GetPoint(pathLength / numberOfSamples * i);
                _pointList[i] = pointOnPath;
            }
        }

Exemple #4

0

Afficher le fichier

        private void CreateRoad()
        {
            //RandomHelper.Random = new Random(1234567);

            // Set isClosed to true join the start and the end of the road.
            bool isClosed = false;

            // Create a new TerrainRoadLayer which paints a road onto the terrain.
            // The road itself is defined by a mesh which is set later.
            _roadLayer = new TerrainRoadLayer(GraphicsService)
            {
                DiffuseColor    = new Vector3(0.5f),
                SpecularColor   = new Vector3(1),
                DiffuseTexture  = ContentManager.Load <Texture2D>("Terrain/Road-Asphalt-Diffuse"),
                NormalTexture   = ContentManager.Load <Texture2D>("Terrain/Road-Asphalt-Normal"),
                SpecularTexture = ContentManager.Load <Texture2D>("Terrain/Road-Asphalt-Specular"),
                HeightTexture   = ContentManager.Load <Texture2D>("Terrain/Road-Asphalt-Height"),

                // The size of the tileable detail textures in world space units.
                TileSize = 5,

                // The border blend range controls how the border of the road fades out.
                // We fade out 5% of the texture on each side of the road.
                BorderBlendRange = new Vector4(0.05f, 0.05f, 0.05f, 0.05f),
            };

            // Create 3D spline path with some semi-random control points.
            _roadPath = new Path3F
            {
                PreLoop    = isClosed ? CurveLoopType.Cycle : CurveLoopType.Linear,
                PostLoop   = isClosed ? CurveLoopType.Cycle : CurveLoopType.Linear,
                SmoothEnds = isClosed,
            };

            // The position of the next path key.
            Vector3 position = new Vector3(
                RandomHelper.Random.NextFloat(-20, 20),
                0,
                RandomHelper.Random.NextFloat(-20, 20));

            // The direction to the next path key.
            Vector3 direction = Quaternion.CreateRotationY(RandomHelper.Random.NextFloat(0, 10)).Rotate(Vector3.Forward);

            // Add path keys.
            for (int j = 0; j < 10; j++)
            {
                // Instead of a normal PathKey3F, we use a TerrainRoadPathKey which allows to control
                // the road with and the side falloff.
                var key = new TerrainRoadPathKey
                {
                    Interpolation = SplineInterpolation.CatmullRom,
                    Parameter     = j,
                    Point         = position,

                    // The width of the road at the path key.
                    Width = RandomHelper.Random.NextFloat(6, 10),

                    // The side falloff (which is used in ClampTerrainToRoad to blend the height values with
                    // the road).
                    SideFalloff = RandomHelper.Random.NextFloat(20, 40),
                };

                _roadPath.Add(key);

                // Get next random position and direction.
                position   += direction * RandomHelper.Random.NextFloat(20, 40);
                position.Y += RandomHelper.Random.NextFloat(-2, 2);
                direction   = Quaternion.CreateRotationY(RandomHelper.Random.NextFloat(-1, 1))
                              .Rotate(direction);
            }

            if (isClosed)
            {
                // To create a closed path the first and the last key should be identical.
                _roadPath[_roadPath.Count - 1].Point = _roadPath[0].Point;
                ((TerrainRoadPathKey)_roadPath[_roadPath.Count - 1]).Width       = ((TerrainRoadPathKey)_roadPath[0]).Width;
                ((TerrainRoadPathKey)_roadPath[_roadPath.Count - 1]).SideFalloff =
                    ((TerrainRoadPathKey)_roadPath[0]).SideFalloff;

                // Since the path is closed we do not have to fade out the start and the end of the road.
                _roadLayer.BorderBlendRange *= new Vector4(1, 0, 1, 0);
            }

            // Convert the path to a mesh.
            Submesh roadSubmesh;
            Aabb    roadAabb;
            float   roadLength;

            TerrainRoadLayer.CreateMesh(
                GraphicsService.GraphicsDevice,
                _roadPath,
                4,
                10,
                0.1f,
                out roadSubmesh,
                out roadAabb,
                out roadLength);

            // Set the mesh in the road layer.
            _roadLayer.SetMesh(roadSubmesh, roadAabb, roadLength, true);

            if (isClosed)
            {
                // When the path is closed, the end texture and the start texture coordinates should
                // match. This is the case if (roadLength / tileSize) is an integer.
                var numberOfTiles = (int)(roadLength / _roadLayer.TileSize);
                _roadLayer.TileSize = roadLength / numberOfTiles;
            }

            // The road layer is added to the layers of a tile. We have to add the road to each terrain
            // tile which it overlaps.
            foreach (var tile in _terrainObject.TerrainNode.Terrain.Tiles)
            {
                if (GeometryHelper.HaveContact(tile.Aabb, _roadLayer.Aabb.Value))
                {
                    tile.Layers.Add(_roadLayer);
                }
            }
        }

Exemple #5

0

Afficher le fichier