/// <summary>
        ///     Cargar información de PortalRendering
        /// </summary>
        public TgcPortalRenderingManager loadFromData(TgcScene scene, TgcPortalRenderingData portalRenderingData)
        {
            var manager = new TgcPortalRenderingManager(scene);

            //Crear dictionary de nombres de los meshes
            var meshDictionary = new Dictionary <string, TgcMesh>();

            foreach (var mesh in scene.Meshes)
            {
                meshDictionary.Add(mesh.Name, mesh);
            }

            //Cargar celdas
            foreach (var cellData in portalRenderingData.cells)
            {
                //Crear cuerpo Convexo
                var convexPoly = new TgcConvexPolyhedron();
                convexPoly.Planes = new Plane[cellData.facePlanes.Length / 4];
                for (var i = 0; i < convexPoly.Planes.Length; i++)
                {
                    convexPoly.Planes[i] = new Plane(
                        cellData.facePlanes[i * 4],
                        cellData.facePlanes[i * 4 + 1],
                        cellData.facePlanes[i * 4 + 2],
                        cellData.facePlanes[i * 4 + 3]
                        );
                }
                convexPoly.BoundingVertices = new Vector3[cellData.boundingVertices.Length / 3];
                for (var i = 0; i < convexPoly.BoundingVertices.Length; i++)
                {
                    convexPoly.BoundingVertices[i] = new Vector3(
                        cellData.boundingVertices[i * 3],
                        cellData.boundingVertices[i * 3 + 1],
                        cellData.boundingVertices[i * 3 + 2]
                        );
                }

                //Crear celda
                var cell = new TgcPortalRenderingCell(cellData.name, convexPoly);
                manager.Cells.Add(cell);

                //Cargar meshes en celda
                for (var i = 0; i < cellData.meshes.Length; i++)
                {
                    var mesh = meshDictionary[cellData.meshes[i]];
                    cell.Meshes.Add(mesh);
                }
            }

            //Cargar portales
            foreach (var portalData in portalRenderingData.portals)
            {
                //BoundingBox del portal
                var boundingBox = new TgcBoundingAxisAlignBox(
                    new Vector3(portalData.pMin[0], portalData.pMin[1], portalData.pMin[2]),
                    new Vector3(portalData.pMax[0], portalData.pMax[1], portalData.pMax[2])
                    );

                //Crear portal
                var portal = new TgcPortalRenderingPortal(portalData.name, boundingBox);
                manager.Portals.Add(portal);

                //Cargar conexiones para celdas A y B
                var cellA = manager.Cells[portalData.cellA];
                var cellB = manager.Cells[portalData.cellB];

                //Poligono del portal para la celda A
                var polygonA = new TgcConvexPolygon();
                polygonA.BoundingVertices = new Vector3[portalData.boundingVerticesA.Length / 3];
                for (var i = 0; i < polygonA.BoundingVertices.Length; i++)
                {
                    polygonA.BoundingVertices[i] = new Vector3(
                        portalData.boundingVerticesA[i * 3],
                        portalData.boundingVerticesA[i * 3 + 1],
                        portalData.boundingVerticesA[i * 3 + 2]
                        );
                }

                //Plano del portal para la celda A
                var planeA = TgcParserUtils.float4ArrayToPlane(portalData.planeA);

                //Crear conexion A
                var connectionA = new TgcPortalRenderingConnection(portal, cellB, polygonA, planeA);
                cellA.Connections.Add(connectionA);

                //Poligono del portal para la celda B
                var polygonB = new TgcConvexPolygon();
                polygonB.BoundingVertices = new Vector3[portalData.boundingVerticesB.Length / 3];
                for (var i = 0; i < polygonB.BoundingVertices.Length; i++)
                {
                    polygonB.BoundingVertices[i] = new Vector3(
                        portalData.boundingVerticesB[i * 3],
                        portalData.boundingVerticesB[i * 3 + 1],
                        portalData.boundingVerticesB[i * 3 + 2]
                        );
                }

                //Plano del portal para la celda B
                var planeB = TgcParserUtils.float4ArrayToPlane(portalData.planeB);

                //Crear conexion B
                var connectionB = new TgcPortalRenderingConnection(portal, cellA, polygonB, planeB);
                cellB.Connections.Add(connectionB);
            }

            return(manager);
        }
예제 #2
0
        /// <summary>
        ///     Parsea la información de PortalRendering
        /// </summary>
        public TgcPortalRenderingData parseFromXmlNode(XmlElement portalRenderingNode)
        {
            var portalRenderingData = new TgcPortalRenderingData();
            int count;
            int i;

            char[] meshSeparator = { ',' };

            //Cells
            var cellsNode = portalRenderingNode.GetElementsByTagName("cells")[0];
            var cellNodes = cellsNode.ChildNodes;

            portalRenderingData.cells = new TgcPortalRenderingCellData[cellNodes.Count];
            i = 0;
            foreach (XmlElement cellElement in cellNodes)
            {
                var cellData = new TgcPortalRenderingCellData();
                portalRenderingData.cells[i++] = cellData;

                //id
                cellData.id = int.Parse(cellElement.Attributes["id"].InnerText);

                //name
                cellData.name = cellElement.Attributes["name"].InnerText;

                //facePlanes
                var facePlanesNode = cellElement.GetElementsByTagName("facePlanes")[0];
                count = int.Parse(facePlanesNode.Attributes["count"].InnerText);
                cellData.facePlanes = TgcParserUtils.parseFloatStream(facePlanesNode.InnerText, count);

                //boundingVertices
                var boundingVerticesNode = cellElement.GetElementsByTagName("boundingVertices")[0];
                count = int.Parse(boundingVerticesNode.Attributes["count"].InnerText);
                cellData.boundingVertices = TgcParserUtils.parseFloatStream(boundingVerticesNode.InnerText, count);

                //meshes
                var meshesNode = cellElement.GetElementsByTagName("meshes")[0];
                count           = int.Parse(meshesNode.Attributes["count"].InnerText);
                cellData.meshes = meshesNode.InnerText.Split(meshSeparator);
            }

            //Portals
            var portalsNode = portalRenderingNode.GetElementsByTagName("portals")[0];
            var portalNodes = portalsNode.ChildNodes;

            portalRenderingData.portals = new TgcPortalRenderingPortalData[portalNodes.Count];
            i = 0;
            foreach (XmlElement portalElement in portalNodes)
            {
                var portalData = new TgcPortalRenderingPortalData();
                portalRenderingData.portals[i++] = portalData;

                //name
                portalData.name = portalElement.Attributes["name"].InnerText;

                //boundingBox
                var boundingBoxNode = portalElement.GetElementsByTagName("boundingBox")[0];
                portalData.pMin = TgcParserUtils.parseFloat3Array(boundingBoxNode.Attributes["min"].InnerText);
                portalData.pMax = TgcParserUtils.parseFloat3Array(boundingBoxNode.Attributes["max"].InnerText);

                //cellA
                var cellAElement = (XmlElement)portalElement.GetElementsByTagName("cellA")[0];
                portalData.cellA = int.Parse(cellAElement.Attributes["id"].InnerText);

                //planeA
                var planeANode = cellAElement.GetElementsByTagName("plane")[0];
                portalData.planeA = TgcParserUtils.parseFloat4Array(planeANode.InnerText);

                //verticesA
                var verticesANode = cellAElement.GetElementsByTagName("vertices")[0];
                count = int.Parse(verticesANode.Attributes["count"].InnerText);
                portalData.boundingVerticesA = TgcParserUtils.parseFloatStream(verticesANode.InnerText, count);

                //cellB
                var cellBElement = (XmlElement)portalElement.GetElementsByTagName("cellB")[0];
                portalData.cellB = int.Parse(cellBElement.Attributes["id"].InnerText);

                //planeB
                var planeBNode = cellBElement.GetElementsByTagName("plane")[0];
                portalData.planeB = TgcParserUtils.parseFloat4Array(planeBNode.InnerText);

                //verticesB
                var verticesBNode = cellBElement.GetElementsByTagName("vertices")[0];
                count = int.Parse(verticesBNode.Attributes["count"].InnerText);
                portalData.boundingVerticesB = TgcParserUtils.parseFloatStream(verticesBNode.InnerText, count);
            }

            return(portalRenderingData);
        }