public static void ConvertMapGeometryToGltf(ConvertMapGeometryToGltf opts) { MapGeometry mapGeometry = ReadMapGeometry(opts.MapGeometryPath); //Material Support missing ModelRoot gltf = mapGeometry.ToGLTF(); gltf.Save(opts.OutputPath); }
public static void ConvertMapGeometryToGltf(ConvertMapGeometryToGltf opts) { MapGeometry mapGeometry = ReadMapGeometry(opts.MapGeometryPath); ModelRoot gltf = mapGeometry.ToGLTF(); gltf.Save(opts.OutputPath); }
private static ReferenceLine CreateReferenceLine(MapLineData lineMapData, string shapeFilePath) { MapFeature[] lineFeatures = lineMapData.Features.ToArray(); if (lineFeatures.Length > 1) { string message = new FileReaderErrorMessageBuilder(shapeFilePath) .Build(RiskeerCommonIOResources.ReferenceLineReader_File_contains_unsupported_multi_polyline); throw new CriticalFileReadException(message); } var referenceLine = new ReferenceLine(); MapFeature referenceLineFeature = lineMapData.Features.First(); MapGeometry[] referenceGeometries = referenceLineFeature.MapGeometries.ToArray(); if (referenceGeometries.Length > 1) { string message = new FileReaderErrorMessageBuilder(shapeFilePath) .Build(RiskeerCommonIOResources.ReferenceLineReader_File_contains_unsupported_multi_polyline); throw new CriticalFileReadException(message); } MapGeometry referenceGeometry = referenceGeometries[0]; referenceLine.SetGeometry(referenceGeometry.PointCollections.First().Select(t => new Point2D(t)).ToArray()); return(referenceLine); }
private void button9_Click(object sender, EventArgs e) { string MAPGEOText = Path.GetFullPath(openmapgeo.FileName); savegltf.Filter = "GLTF|*.gltf|GLB|*.glb"; if (savegltf.ShowDialog() == DialogResult.OK) { string outputgltf = Path.GetFullPath(savegltf.FileName); try { MapGeometry mapgeo = new MapGeometry(MAPGEOText); var convertmap = mapgeo.ToGLTF(); convertmap.SaveGLB(outputgltf); MessageBox.Show("Exported to GLTF/GLB.", $"Files Exported!", MessageBoxButtons.OK, MessageBoxIcon.Information); } catch (FileNotFoundException ex) { MessageBox.Show("MapFile is missing. Make sure you load the correct MAPGEO file!", $"Error: Can't find .mapgeo file!", MessageBoxButtons.OK, MessageBoxIcon.Error); } catch (System.ArgumentException ag) { MessageBox.Show("Make sure you load a file before exporting it!", $"Error: No file is loaded!", MessageBoxButtons.OK, MessageBoxIcon.Error); } } }
private static void AssertCombinedFailureMechanismSectionAssemblyResultMapData(IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedAssemblyResults, ReferenceLine referenceLine, MapData mapData) { Assert.IsInstanceOf <MapLineData>(mapData); var assemblyResultMapData = (MapLineData)mapData; int expectedNrOfResults = expectedAssemblyResults.Count(); IEnumerable <MapFeature> mapFeatures = assemblyResultMapData.Features; Assert.AreEqual(expectedNrOfResults, mapFeatures.Count()); for (var i = 0; i < expectedNrOfResults; i++) { CombinedFailureMechanismSectionAssemblyResult expectedAssemblyResult = expectedAssemblyResults.ElementAt(i); MapFeature actualFeature = mapFeatures.ElementAt(i); MapGeometry mapGeometry = actualFeature.MapGeometries.Single(); AssertEqualPointCollections(referenceLine, expectedAssemblyResult, mapGeometry); Assert.AreEqual(1, actualFeature.MetaData.Keys.Count); Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.TotalResult), mapFeatures.ElementAt(i).MetaData["Duidingsklasse"]); } }
static void TestMapgeo() { MapGeometry mgeo = new MapGeometry(@"C:/Users/Crauzer/Desktop/data/maps/mapgeometry/sr/base_srx.mapgeo"); string randomMaterialName = mgeo.Models[180].Submeshes[0].Material; mgeo.Models.Clear(); OBJFile object1 = new OBJFile("room155.obj"); OBJFile object2 = new OBJFile("room156.obj"); OBJFile object3 = new OBJFile("room157.obj"); AddOBJ(object1, "MapGeo_Instance_0"); AddOBJ(object2, "MapGeo_Instance_1"); AddOBJ(object3, "MapGeo_Instance_2"); mgeo.Write("base_srx.mapgeo.edited", 7); void AddOBJ(OBJFile obj, string name) { //We will add each object 2 times just for fun to see how transformation works (List <ushort> indices, List <MapGeometryVertex> vertices) = obj.GetMGEOData(); Matrix4x4 transformation = Matrix4x4.CreateTranslation(new Vector3(0, 50, 100)); MapGeometrySubmesh submesh = new MapGeometrySubmesh("", 0, (uint)indices.Count, 0, (uint)vertices.Count); MapGeometryModel model1 = new MapGeometryModel(name, vertices, indices, new List <MapGeometrySubmesh>() { submesh }, MapGeometryLayer.AllLayers); mgeo.AddModel(model1); } }
public FirstPersonRenderer(GameSettings settings, MapGeometry map, ScreenMessage screenMessage) { _settings = settings; _map = map; _screenMessage = screenMessage; Interpreter = new FirstPersonWorldInterpreter(); }
private static void ConvertMapGeometryToGltf(FileConversionParameter parameter) { WadEntry mapGeometryWadEntry = parameter.Parameter; MapGeometry mapGeometry = new MapGeometry(mapGeometryWadEntry.GetDataHandle().GetDecompressedStream()); ModelRoot gltf = mapGeometry.ToGLTF(); gltf.SaveGLB(Path.ChangeExtension(parameter.OutputPath, "glb")); }
private static void ConvertMapGeometryToGltf(FileConversionParameter parameter) { WADEntry mapGeometryWadEntry = parameter.Parameter; using MemoryStream stream = new MemoryStream(mapGeometryWadEntry.GetContent(true)); MapGeometry mapGeometry = new MapGeometry(stream); ModelRoot gltf = mapGeometry.ToGLTF(); gltf.SaveGLB(Path.ChangeExtension(parameter.OutputPath, "glb")); }
private World(WorldInfo info, MapData map, GameObject gameObj) { Info = info; gameObject = gameObj; Geometry = new MapGeometry(map); Entities = new EntityManager(this, map); Physics = new PhysicsSystem(this); timer.Start(); }
static void Main(string[] args) { //SimpleSkin skn = new SimpleSkin("C:/dev/proxy/kek.skn"); // //OBJConverter.ConvertSKN(skn).Write("C:/dev/proxy/kek.obj"); MapGeometry mgeo = new MapGeometry("C:/Users/Crauzer/Desktop/New Folder/e7ef6cc4fece0526.mapgeo"); mgeo.Write("C:/Users/Crauzer/Desktop/New Folder/e7ef6cc4fece0526_write.mapgeo", 11); mgeo = new MapGeometry("C:/Users/Crauzer/Desktop/New Folder/e7ef6cc4fece0526_write.mapgeo"); }
public OverheadRenderer(GameSettings settings, MapGeometry map) { _settings = settings; _map = map; _verticesInScreenCoords = new Point[map.Vertices.Length]; _camera.RenderScale = _settings.RenderScale; _settings.FollowModeChanged += (s, e) => _camera.ViewOffset = Vector2.Zero; _settings.DrawAntiAliasedModeChanged += (s, e) => PickLineDrawer(); _settings.RenderScaleChanged += (s, e) => _camera.RenderScale = _settings.RenderScale; PickLineDrawer(); }
private static void AssertEqualPointCollections(ReferenceLine referenceLine, CombinedFailureMechanismSectionAssemblyResult sectionAssemblyResult, MapGeometry geometry) { IEnumerable <Point2D> expectedGeometry = FailureMechanismSectionHelper.GetFailureMechanismSectionGeometry( referenceLine, sectionAssemblyResult.SectionStart, sectionAssemblyResult.SectionEnd).ToArray(); CollectionAssert.IsNotEmpty(expectedGeometry); CollectionAssert.AreEqual(expectedGeometry, geometry.PointCollections.Single()); }
public void LoadMap() { using (var wad = WadReader.Read("freedoom2-udmf.wad")) { _map = new MapGeometry(MapData.LoadFrom(wad.GetTextmapStream("MAP28"))); } _sectorBounds = new STRtree <int>(); for (int sectorId = 0; sectorId < _map.Sectors.Length; sectorId++) { _sectorBounds.Insert(_map.GetSectorMinimumBoundingRectangle(sectorId), sectorId); } _sectorBounds.Build(); }
public void CreateCombinedFailureMechanismSectionAssemblyFeatures_WithAssessmentSection_ReturnsFeatureCollection() { // Setup var random = new Random(21); var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>()); assessmentSection.ReferenceLine.SetGeometry(new[] { new Point2D(0, 0), new Point2D(2, 2) }); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; CombinedFailureMechanismSectionAssembly[] failureMechanismSectionAssembly = { CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 20), CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 21) }; calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper( failureMechanismSectionAssembly, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1); // Call IEnumerable <MapFeature> features = AssessmentSectionAssemblyMapDataFeaturesFactory.CreateCombinedFailureMechanismSectionAssemblyFeatures(assessmentSection); // Assert IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedAssemblyResults = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection); int expectedNrOfResults = expectedAssemblyResults.Count(); Assert.AreEqual(expectedNrOfResults, features.Count()); for (var i = 0; i < expectedNrOfResults; i++) { CombinedFailureMechanismSectionAssemblyResult expectedAssemblyResult = expectedAssemblyResults.ElementAt(i); MapFeature actualFeature = features.ElementAt(i); MapGeometry mapGeometry = actualFeature.MapGeometries.Single(); AssertEqualPointCollections(assessmentSection.ReferenceLine, expectedAssemblyResult, mapGeometry); Assert.AreEqual(1, actualFeature.MetaData.Keys.Count); Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.TotalResult), features.ElementAt(i).MetaData["Duidingsklasse"]); } } }
static void Main(string[] args) { //Deletes existing material file. if (File.Exists(@"material_output\material.py")) { File.Delete(@"material_output\material.py"); } string MapMgeoPath = "MapFile/base_srx.mapgeo"; MapGeometry MapMgeo = new MapGeometry(MapMgeoPath); MapMgeo.Models.Clear(); BildgeWaterRift(MapMgeo); }
private static MapFeature CreateMapFeatureForPolygonFeature(IFeature polygonFeature) { var geometries = new List <MapGeometry>(); for (var i = 0; i < polygonFeature.Geometry.NumGeometries; i++) { var basicPolygon = (IPolygon)polygonFeature.Geometry.GetGeometryN(i); var mapGeometry = new MapGeometry(GetMapGeometryPointCollections(basicPolygon).ToArray()); geometries.Add(mapGeometry); } return(new MapFeature(geometries)); }
private static MapFeature CreateMapFeatureForLineFeature(IFeature lineFeature) { var geometries = new List <MapGeometry>(); for (var i = 0; i < lineFeature.Geometry.NumGeometries; i++) { IGeometry polylineGeometry = lineFeature.Geometry.GetGeometryN(i); var mapGeometry = new MapGeometry(GetMapGeometryPointCollections(polylineGeometry.Coordinates)); geometries.Add(mapGeometry); } return(new MapFeature(geometries)); }
private static LineString CreateLineStringFromMapFeature(MapFeature mapFeature) { if (mapFeature.MapGeometries.Count() != 1) { throw new ArgumentException(Resources.PointShapeFileWriter_CreatePointFromMapFeature_A_feature_can_only_contain_one_geometry); } MapGeometry geometry = mapFeature.MapGeometries.First(); IEnumerable <Point2D> mapGeometryPointCollection = geometry.PointCollections.First(); Coordinate[] coordinates = mapGeometryPointCollection.Select(p => new Coordinate(p.X, p.Y)).ToArray(); return(new LineString(coordinates)); }
//Base Map public static void Add_Layer1(OBJFile obj, string name, string path, MapGeometry mgeo, int i, string fullpath, string mapname, string Lightmode, string Fogmode, string Alphamode) { (List <ushort> indices, List <MapGeometryVertex> vertices) = obj.GetMGEOData(); MapGeometrySubmesh submesh = new MapGeometrySubmesh(path, 0, (uint)indices.Count, 0, (uint)vertices.Count); MapGeometryModel room = new MapGeometryModel(name, vertices, indices, new List <MapGeometrySubmesh>() { submesh }, MapGeometryLayer.Layer1); mgeo.AddModel(room); //Porting material file to league format string ShaderPath = "MapFile/ShaderTemp/DefaultEnv_Flat_AlphaTest.py"; List <string> materials = new List <string>(); materials = File.ReadAllLines(ShaderPath).ToList(); string number = $"{i}"; string readfile = File.ReadLines($@"{fullpath}").Skip(12).Take(1).First(); //Get texture name without extension string replace = readfile.Replace("\\\\", " \\\\ "); var gettexturename = string.Join(" ", replace.Split().Reverse().Take(1).Reverse()); string text = gettexturename.Replace(".dds", ""); string texturename = gettexturename; if (mapname == string.Empty) { mapname = "textures"; } //Add Settings to material var newList = materials.Select(s => s.Replace("Texture_Name", texturename)).ToList(); var newList2 = newList.Select(s => s.Replace("Map_Name", mapname)).ToList(); var newList3 = newList2.Select(s => s.Replace("Material_Name", path)).ToList(); var newList4 = newList3.Select(s => s.Replace("NOBAKEDLIGHTINGTEMP", Lightmode)).ToList(); var newList5 = newList4.Select(s => s.Replace("DISABLEDEPTHFOG", Fogmode)).ToList(); var newList6 = newList5.Select(s => s.Replace("PREMULTIPLIEDALPHA", Alphamode)).ToList(); //Sun Properties //Writes Directory.CreateDirectory("material_output"); File.AppendAllLines(@"material_output\" + "material.py", newList6); }
void Awake() { if (GAME == null) { GAME = this; DontDestroyOnLoad(GAME); } else { Destroy(this); } TOON = GameObject.FindGameObjectWithTag("ToonManager").GetComponent <ToonPool>(); PART = GameObject.FindGameObjectWithTag("GeometryManager").GetComponent <MapGeometry>(); MAP = GameObject.FindGameObjectWithTag("MapManager").GetComponent <MapManager>(); }
public void CreateSinglePointMapFeature_WithPoint_CreatesASinglePointMapFeature() { // Setup var point = new Point2D(0, 0); // Call MapFeature pointMapFeature = RiskeerMapDataFeaturesFactoryHelper.CreateSinglePointMapFeature(point); // Assert MapGeometry[] mapGeometries = pointMapFeature.MapGeometries.ToArray(); Assert.AreEqual(1, mapGeometries.Length); MapGeometry mapGeometry = mapGeometries.First(); IEnumerable <Point2D>[] geometryPointCollections = mapGeometry.PointCollections.ToArray(); Assert.AreEqual(1, geometryPointCollections.Length); Assert.AreSame(point, geometryPointCollections.First().First()); }
/// <summary> /// Asserts whether the <see cref="MapData"/> contains the data that is representative for the <paramref name="sections"/>. /// </summary> /// <param name="sections">The sections that contain the original data.</param> /// <param name="mapData">The <see cref="MapData"/> that needs to be asserted.</param> /// <exception cref="AssertionException">Thrown when: /// <list type="bullet"> /// <item><paramref name="mapData"/> is not <see cref="MapLineData"/>;</item> /// <item>the name of the <see cref="MapData"/> is not <c>"Vakindeling"</c>;</item> /// <item>the number of sections and features in <see cref="MapData"/> are not the same;</item> /// <item>the points of a section and the geometry of a corresponding feature are not the same.</item> /// </list> /// </exception> public static void AssertFailureMechanismSectionsMapData(IEnumerable <FailureMechanismSection> sections, MapData mapData) { Assert.IsInstanceOf <MapLineData>(mapData); Assert.AreEqual("Vakindeling", mapData.Name); var sectionsMapLinesData = (MapLineData)mapData; MapFeature[] sectionMapLinesFeatures = sectionsMapLinesData.Features.ToArray(); FailureMechanismSection[] sectionsArray = sections.ToArray(); Assert.AreEqual(sectionsArray.Length, sectionMapLinesFeatures.Length); for (var index = 0; index < sectionsArray.Length; index++) { MapGeometry geometry = sectionMapLinesFeatures[index].MapGeometries.First(); FailureMechanismSection failureMechanismSection = sectionsArray[index]; CollectionAssert.AreEquivalent(failureMechanismSection.Points, geometry.PointCollections.First()); } }
/// <summary> /// Asserts whether the <see cref="MapData"/> contains the data that is representative for the <paramref name="foreshoreProfiles"/>. /// </summary> /// <param name="foreshoreProfiles">The foreshore profiles that contain the original data.</param> /// <param name="mapData">The <see cref="MapData"/> that needs to be asserted.</param> /// <exception cref="AssertionException">Thrown when: /// <list type="bullet"> /// <item><paramref name="mapData"/> is not <see cref="MapLineData"/>;</item> /// <item>the name of the <see cref="MapData"/> is not <c>Voorlandprofielen</c>;</item> /// <item>the amount of features in <paramref name="mapData"/> is not equal to the length of the <paramref name="foreshoreProfiles"/>;</item> /// <item>the geometries of the features in <paramref name="mapData"/> are not equal to the expected geometry of the <paramref name="foreshoreProfiles"/>.</item> /// </list> /// </exception> public static void AssertForeshoreProfilesMapData(IEnumerable <ForeshoreProfile> foreshoreProfiles, MapData mapData) { Assert.IsInstanceOf <MapLineData>(mapData); Assert.AreEqual("Voorlandprofielen", mapData.Name); var foreshoreProfilesData = (MapLineData)mapData; ForeshoreProfile[] foreshoreProfileArray = foreshoreProfiles.ToArray(); Assert.AreEqual(foreshoreProfileArray.Length, foreshoreProfilesData.Features.Count()); for (var i = 0; i < foreshoreProfileArray.Length; i++) { IEnumerable <Point2D> expectedGeometry = GetWorldPoints(foreshoreProfileArray[i]); MapGeometry profileDataA = foreshoreProfilesData.Features.ElementAt(i).MapGeometries.First(); CollectionAssert.AreEquivalent(expectedGeometry, profileDataA.PointCollections.First()); } }
static void BildgeWaterRift(MapGeometry mgeo) { //Model Bulk Loading var fileCount = (from file in Directory.EnumerateFiles(@"K:\Riot Games\LeagueSkins\BildgewaterRift\3dmodelsnewnew", "*.obj", System.IO.SearchOption.AllDirectories) select file).Count(); int OBJsToCreate = fileCount + 1; OBJFile[] OBJs = new OBJFile[OBJsToCreate]; for (int i = 1; i < OBJsToCreate; i++) { OBJs[i] = new OBJFile($@"K:\Riot Games\LeagueSkins\BildgewaterRift\3dmodelsnewnew\room{i}.obj"); int j = i; AddModel(OBJs[i], $"MapGeo_Instance_{i}", $"Maps/KitPieces/Summoners_Rift/Materials/room{i}", mgeo, i, j); } mgeo.Write(@"K:\Riot Games\LeagueSkins\BildgewaterRift\Map11\data\maps\mapgeometry\sr\base_srx.mapgeo", 11); }
public CollidingThing( MapGeometry map, int currentSectorId, Vector2 position, Vector2 direction, float angle, float radius) { _map = map; _possibleSectorsToEnter = new List <int>(_map.Sectors.Length); Position = position; Direction = direction; Angle = angle; CurrentSectorId = currentSectorId; Radius = radius; VerticalPosition = map.Sectors[currentSectorId].Info.HeightFloor; _heightSourceSectorId = CurrentSectorId; }
private static void AssertDikeProfiles(IEnumerable <DikeProfile> dikeProfiles, MapData mapData) { Assert.NotNull(dikeProfiles, "dikeProfiles should never be null."); var dikeProfilesData = (MapLineData)mapData; DikeProfile[] dikeProfileArray = dikeProfiles.ToArray(); Assert.IsInstanceOf <MapLineData>(mapData); int dikeProfileCount = dikeProfileArray.Length; Assert.AreEqual(dikeProfileCount, dikeProfilesData.Features.Count()); for (var i = 0; i < dikeProfileCount; i++) { MapGeometry profileDataA = dikeProfilesData.Features.ElementAt(i).MapGeometries.First(); CollectionAssert.AreEquivalent(dikeProfileArray[0].DikeGeometry, profileDataA.PointCollections.First()); } Assert.AreEqual("Dijkprofielen", mapData.Name); }
public static IEnumerable <Tuple <string, OBJFile> > ConvertMGEOModels(MapGeometry mgeo) { foreach (MapGeometryModel model in mgeo.Models) { List <Vector3> vertices = new List <Vector3>(); List <Vector3> normals = new List <Vector3>(); List <Vector2> uvs = new List <Vector2>(); foreach (MapGeometryVertex vertex in model.Vertices) { vertices.Add(model.Transformation.ApplyTransformation(vertex.Position.Value)); normals.Add(vertex.Normal.Value); if (vertex.DiffuseUV != null) { uvs.Add(vertex.DiffuseUV.Value); } } yield return(new Tuple <string, OBJFile>(model.Name, new OBJFile(vertices, model.Indices.Select(x => (uint)x).ToList(), uvs, normals))); } }
/// <summary> /// Create a new instance of <see cref="MapLineData"/> from a reference line and a traject id. /// </summary> /// <param name="referenceLine">The <see cref="ReferenceLine"/> supplying the geometry information /// for the new <see cref="MapLineData"/> object.</param> /// <param name="id">The id of the assessment section to which the reference line is associated.</param> /// <returns>A new instance of <see cref="MapLineData"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="referenceLine"/> or <paramref name="id"/> /// is <c>null</c>.</exception> /// <exception cref="ArgumentException">Thrown when <paramref name="id"/> is empty or consists only of whitespace.</exception> private static MapLineData CreateMapLineData(ReferenceLine referenceLine, string id) { if (referenceLine == null) { throw new ArgumentNullException(nameof(referenceLine)); } if (id == null) { throw new ArgumentNullException(nameof(id)); } if (string.IsNullOrWhiteSpace(id)) { throw new ArgumentException(Resources.ReferenceLineWriter_CreateMapLineData_Traject_cannot_be_empty, nameof(id)); } var referenceLineGeometry = new MapGeometry( new List <IEnumerable <Point2D> > { referenceLine.Points }); var mapFeature = new MapFeature(new[] { referenceLineGeometry }); mapFeature.MetaData.Add(Resources.ReferenceLineWriter_CreateMapLineData_Traject_id, id); return(new MapLineData(RiskeerCommonDataResources.ReferenceLine_DisplayName) { Features = new[] { mapFeature } }); }
public void ParameteredConstructor_WithPoints_PointsSet() { // Setup var list1 = new List <Point2D> { new Point2D(1.1, 2.2), new Point2D(3.3, 4.4), new Point2D(5.5, 6.6) }; var list2 = new List <Point2D> { new Point2D(7.7, 8.8), new Point2D(9.9, 10.1), new Point2D(11.11, 12.12) }; var list3 = new List <Point2D> { new Point2D(13.13, 14.14), new Point2D(15.15, 16.16), new Point2D(17.17, 18.18) }; var geometriesList = new List <IEnumerable <Point2D> > { list1, list2, list3 }; // Call var mapGeometry = new MapGeometry(geometriesList); // Assert CollectionAssert.AreEqual(geometriesList, mapGeometry.PointCollections); }