Esempio n. 1
0
        protected void Start()
        {
            var hexGridSurface = RectangularHexGrid.Create(
                HexGridDescriptor.CreateSideUp(true, HexGridAxisStyles.StaggeredSymmetric),
                Vector3.zero, Quaternion.Euler(90f, 0f, 0f),
                false, false,
                new IntVector2(topologyWidth, topologyHeight));

            _surface = hexGridSurface;

            Vector3[] vertexPositionsArray;
            _topology            = hexGridSurface.CreateManifold(out vertexPositionsArray);
            _vertexPositions     = vertexPositionsArray.AsVertexAttribute();
            _facePositions       = FaceAttributeUtility.CalculateFaceCentroidsFromVertexPositions(_topology.internalFaces, _vertexPositions);
            _faceCornerBisectors = EdgeAttributeUtility.CalculateFaceEdgeBisectorsFromVertexPositions(_topology.internalFaces, _vertexPositions, _facePositions);
            _faceBlockedStates   = new bool[_topology.internalFaces.Count].AsFaceAttribute();

            var triangulation = new SeparatedFacesUmbrellaTriangulation(2,
                                                                        (Topology.FaceEdge edge, DynamicMesh.IIndexedVertexAttributes vertexAttributes) =>
            {
                vertexAttributes.position = _vertexPositions[edge];
                vertexAttributes.normal   = Vector3.up;
                vertexAttributes.color    = borderColor;
                vertexAttributes.Advance();

                vertexAttributes.position = _vertexPositions[edge] + _faceCornerBisectors[edge] * 0.05f;
                vertexAttributes.normal   = (vertexAttributes.position + Vector3.up - _facePositions[edge.nearFace]).normalized;
                vertexAttributes.color    = normalColor;
                vertexAttributes.Advance();
            },
                                                                        (Topology.Face face, DynamicMesh.IIndexedVertexAttributes vertexAttributes) =>
            {
                vertexAttributes.position = _facePositions[face];
                vertexAttributes.normal   = Vector3.up;
                vertexAttributes.color    = normalColor;
                vertexAttributes.Advance();
            });

            _dynamicMesh = DynamicMesh.Create(
                _topology.enumerableInternalFaces,
                DynamicMesh.VertexAttributes.Position |
                DynamicMesh.VertexAttributes.Normal |
                DynamicMesh.VertexAttributes.Color,
                triangulation);

            foreach (var mesh in _dynamicMesh.submeshes)
            {
                var meshFilter = Instantiate(submeshPrefab);
                meshFilter.mesh = mesh;
                meshFilter.transform.SetParent(transform, false);
            }

            var partioning = UniversalFaceSpatialPartitioning.Create(_surface, _topology, _vertexPositions);
            var picker     = GetComponent <FaceSpatialPartitioningPicker>();

            picker.partitioning = partioning;
        }
Esempio n. 2
0
            public static IEdgeAttribute <TAttributeValue>[] GetRingAttributes <TAttributeValue>(Topology topology, InputSlot[] inputSlots)
            {
                if (inputSlots.Length == 0)
                {
                    return(null);
                }
                var array = new IEdgeAttribute <TAttributeValue> [inputSlots.Length];

                for (int i = 0; i < inputSlots.Length; ++i)
                {
                    var attribute = inputSlots[i].GetAsset <IEdgeAttribute <TAttributeValue> >();
                    if (attribute is IFaceAttribute <TAttributeValue> )
                    {
                        attribute = new TwinEdgeAttributeWrapper <TAttributeValue>(topology, attribute);
                    }
                    array[i] = attribute;
                }
                return(array);
            }
Esempio n. 3
0
        private void DestroyOldGame()
        {
            if (_surface == null)
            {
                return;
            }

            var existingMeshCount = gameBoardMeshes.childCount;

            for (int i = 0; i < existingMeshCount; ++i)
            {
                Destroy(gameBoardMeshes.GetChild(i).gameObject);
            }

            foreach (var face in _topology.internalFaces)
            {
                if (_facePieces[face] != null)
                {
                    Destroy(_facePieces[face].gameObject);
                }
            }

            _surface             = null;
            _topology            = null;
            _vertexPositions     = null;
            _facePositions       = null;
            _innerAngleBisectors = null;
            _facePieces          = null;
            _faceBoardStates     = null;
            _partitioning        = null;
            _dynamicMesh         = null;

            _picker.partitioning = null;
            _picker.enabled      = false;

            _gameActive = false;
        }
 public void SubdividedIcosahedronFaceEdgeMidpointWeightedIntersections()
 {
     CreateSubdividedIcosahedron(1f);
     edgeMidpoints = EdgeAttributeUtility.CalculateVertexEdgeMidpointsFromVertexPositions(topology.vertexEdges, vertexPositions);
     FaceEdgeMidpointWeightedIntersections();
 }
 public void CubeFaceEdgeMidpointWeightedIntersections()
 {
     CreateCube(1f);
     edgeMidpoints = EdgeAttributeUtility.CalculateVertexEdgeMidpointsFromVertexPositions(topology.vertexEdges, vertexPositions);
     FaceEdgeMidpointWeightedIntersections();
 }
 public void LargeDistortedHexGridFaceEdgeMidpointWeightedIntersections()
 {
     CreateDistortedHexGrid(8, 8, 1);
     edgeMidpoints = EdgeAttributeUtility.CalculateVertexEdgeMidpointsFromVertexPositions(topology.vertexEdges, vertexPositions);
     FaceEdgeMidpointWeightedIntersections();
 }
 public void SmallHexGridFaceEdgeMidpointWeightedIntersections()
 {
     CreateHexGrid(2, 2);
     edgeMidpoints = EdgeAttributeUtility.CalculateVertexEdgeMidpointsFromVertexPositions(topology.vertexEdges, vertexPositions);
     FaceEdgeMidpointWeightedIntersections();
 }
Esempio n. 8
0
        protected void Start()
        {
            orbitalCamera.enabled = !isInverted;
            pivotalCamera.enabled = isInverted;

            exteriorLight.enabled = !isInverted;
            interiorLight.enabled = isInverted;

            _lightVector = (isInverted ? interiorLight : exteriorLight).transform.position;
            _lightAxis   = Vector3.Cross(Vector3.Cross(Vector3.up, _lightVector), _lightVector);

            RenderSettings.ambientLight          = new Color(0.3f, 0.4f, 0.5f);
            RenderSettings.ambientIntensity      = 0.25f;
            RenderSettings.customReflection      = whiteCubeMap;
            RenderSettings.reflectionIntensity   = 0.125f;
            RenderSettings.defaultReflectionMode = UnityEngine.Rendering.DefaultReflectionMode.Custom;

            _picker = GetComponent <FaceSpatialPartitioningPicker>();

            _surface = SphericalSurface.Create(Vector3.up, Vector3.right, 10f, isInverted);
            Vector3[] baseVertexPositionsArray;
            Topology  baseTopology;

            SphericalManifoldUtility.CreateIcosahedron(_surface, out baseTopology, out baseVertexPositionsArray);

            Vector3[] vertexPositionsArray;
            SphericalManifoldUtility.Subdivide(_surface, baseTopology, baseVertexPositionsArray.AsVertexAttribute(), topologySubdivision, out _topology, out vertexPositionsArray);

            _vertexPositions = PositionalVertexAttribute.Create(_surface, vertexPositionsArray);

            SphericalManifoldUtility.MakeDual(_surface, _topology, _vertexPositions, out vertexPositionsArray);
            _vertexPositions = PositionalVertexAttribute.Create(_surface, vertexPositionsArray);

            var regularityWeight = 0.5f;
            var equalAreaWeight  = 1f - regularityWeight;

            var regularityRelaxedVertexPositions = new Vector3[_topology.vertices.Count].AsVertexAttribute();
            var equalAreaRelaxedVertexPositions  = new Vector3[_topology.vertices.Count].AsVertexAttribute();
            var relaxedVertexPositions           = regularityRelaxedVertexPositions;
            var faceCentroids      = PositionalFaceAttribute.Create(_surface, _topology.internalFaces.Count);
            var faceCentroidAngles = new float[_topology.faceEdges.Count].AsEdgeAttribute();
            var vertexAreas        = new float[_topology.vertices.Count].AsVertexAttribute();

            FaceAttributeUtility.CalculateFaceCentroidsFromVertexPositions(_topology.internalFaces, _vertexPositions, faceCentroids);
            VertexAttributeUtility.CalculateVertexAreasFromVertexPositionsAndFaceCentroids(_topology.vertices, _vertexPositions, faceCentroids, vertexAreas);

            Func <float> relaxIterationFunction = () =>
            {
                SphericalManifoldUtility.RelaxVertexPositionsForRegularity(_surface, _topology, _vertexPositions, true, regularityRelaxedVertexPositions);
                SphericalManifoldUtility.RelaxVertexPositionsForEqualArea(_surface, _topology, _vertexPositions, true, equalAreaRelaxedVertexPositions, faceCentroids, faceCentroidAngles, vertexAreas);
                for (int i = 0; i < relaxedVertexPositions.Count; ++i)
                {
                    relaxedVertexPositions[i] = regularityRelaxedVertexPositions[i] * regularityWeight + equalAreaRelaxedVertexPositions[i] * equalAreaWeight;
                }
                var relaxationAmount = SphericalManifoldUtility.CalculateRelaxationAmount(_vertexPositions, relaxedVertexPositions);
                for (int i = 0; i < _vertexPositions.Count; ++i)
                {
                    _vertexPositions[i] = relaxedVertexPositions[i];
                }
                return(relaxationAmount);
            };

            Func <bool> repairFunction = () =>
            {
                return(SphericalManifoldUtility.ValidateAndRepair(_surface, _topology, _vertexPositions, 0.5f, true));
            };

            Action relaxationLoopFunction = TopologyRandomizer.CreateRelaxationLoopFunction(20, 20, 0.95f, relaxIterationFunction, repairFunction);

            TopologyRandomizer.Randomize(
                _topology, 1, 0.1f,
                3, 3, 5, 7, true,
                _random,
                relaxationLoopFunction);

            _facePositions = PositionalFaceAttribute.Create(_surface, _topology.internalFaces.Count);
            FaceAttributeUtility.CalculateFaceCentroidsFromVertexPositions(_topology.internalFaces, _vertexPositions, _facePositions);

            _maximumFaceDistance = 0f;
            foreach (var edge in _topology.faceEdges)
            {
                var distance = Geometry.AngleBetweenVectors(_facePositions[edge.nearFace], _facePositions[edge.farFace]) * _surface.radius;
                _maximumFaceDistance = Mathf.Max(_maximumFaceDistance, distance);
            }

            _innerAngleBisectors = EdgeAttributeUtility.CalculateFaceEdgeBisectorsFromVertexPositions(_topology.internalFaces, _vertexPositions, _facePositions);

            _innerVertexPositions = new Vector3[_topology.faceEdges.Count].AsEdgeAttribute();
            foreach (var edge in _topology.faceEdges)
            {
                _innerVertexPositions[edge] = _vertexPositions[edge] + _innerAngleBisectors[edge] * 0.03f;
            }

            _faceNormals      = FaceAttributeUtility.CalculateFaceNormalsFromSurface(_topology.faces, _surface, _facePositions);
            _faceUVFrames     = FaceAttributeUtility.CalculatePerFaceSphericalUVFramesFromFaceNormals(_topology.faces, _faceNormals, Quaternion.identity);
            _faceOuterEdgeUVs = EdgeAttributeUtility.CalculatePerFaceUnnormalizedUVsFromVertexPositions(_topology.faces, _vertexPositions, _faceUVFrames);
            _faceInnerEdgeUVs = EdgeAttributeUtility.CalculatePerFaceUnnormalizedUVsFromVertexPositions(_topology.faces, _innerVertexPositions, _faceUVFrames);
            _faceCenterUVs    = FaceAttributeUtility.CalculateUnnormalizedUVsFromFacePositions(_topology.faces, _facePositions, _faceUVFrames);

            var faceMinUVs   = new Vector2[_topology.faces.Count].AsFaceAttribute();
            var faceRangeUVs = new Vector2[_topology.faces.Count].AsFaceAttribute();

            FaceAttributeUtility.CalculateFaceEdgeMinAndRangeValues(_topology.faces, _faceOuterEdgeUVs, faceMinUVs, faceRangeUVs);

            foreach (var face in _topology.faces)
            {
                var uvMin    = faceMinUVs[face];
                var uvRange  = faceRangeUVs[face];
                var adjusted = AspectRatioUtility.Expand(new Rect(uvMin.x, uvMin.y, uvRange.x, uvRange.y), 1f);
                faceMinUVs[face]   = adjusted.min;
                faceRangeUVs[face] = adjusted.size;
            }

            _faceOuterEdgeUVs = EdgeAttributeUtility.CalculatePerFaceUniformlyNormalizedUVsFromFaceUVMinAndRange(_topology.faces, faceMinUVs, faceRangeUVs, _faceOuterEdgeUVs);
            _faceInnerEdgeUVs = EdgeAttributeUtility.CalculatePerFaceUniformlyNormalizedUVsFromFaceUVMinAndRange(_topology.faces, faceMinUVs, faceRangeUVs, _faceInnerEdgeUVs);
            _faceCenterUVs    = FaceAttributeUtility.CalculateUniformlyNormalizedUVsFromFaceUVMinAndRange(_topology.faces, faceMinUVs, faceRangeUVs, _faceCenterUVs);

            _partitioning        = UniversalFaceSpatialPartitioning.Create(_surface, _topology, _vertexPositions);
            _picker.partitioning = _partitioning;
            _picker.enabled      = true;

            _faceTerrainIndices = new int[_topology.faces.Count].AsFaceAttribute();
            var terrainWeights   = new int[] { grassWeight, waterWeight, desertWeight, mountainWeight };
            int terrainWeightSum = 0;

            foreach (var weight in terrainWeights)
            {
                terrainWeightSum += weight;
            }

            var rootFaces     = new List <Topology.Face>();
            var rootFaceEdges = new List <Topology.FaceEdge>();

            for (int regionIndex = 0; regionIndex < geographicalRegionCount; ++regionIndex)
            {
                Topology.Face face;
                do
                {
                    face = _topology.internalFaces[_random.Index(_topology.internalFaces.Count)];
                } while (rootFaces.Contains(face));
                rootFaces.Add(face);
                foreach (var edge in face.edges)
                {
                    rootFaceEdges.Add(edge);
                }
                _faceTerrainIndices[face] = _random.WeightedIndex(terrainWeights, terrainWeightSum);
            }

            TopologyVisitor.VisitFacesInRandomOrder(rootFaceEdges, (FaceEdgeVisitor visitor) =>
            {
                _faceTerrainIndices[visitor.edge.farFace] = _faceTerrainIndices[visitor.edge.nearFace];

                visitor.VisitInternalNeighborsExceptSource();
            },
                                                    _random);

            _faceSeenStates  = new bool[_topology.faces.Count].AsFaceAttribute();
            _faceSightCounts = new int[_topology.faces.Count].AsFaceAttribute();

            var triangulation = new SeparatedFacesUmbrellaTriangulation(2,
                                                                        (Topology.FaceEdge edge, DynamicMesh.IIndexedVertexAttributes vertexAttributes) =>
            {
                var face         = edge.nearFace;
                var faceNormal   = _faceNormals[face];
                var gridOverlayU = GetGridOverlayU(false, _faceSeenStates[face], _faceSightCounts[face]);

                vertexAttributes.position = _vertexPositions[edge];
                vertexAttributes.normal   = faceNormal;
                vertexAttributes.uv1      = AdjustSurfaceUV(_faceOuterEdgeUVs[edge], _faceTerrainIndices[face]);
                vertexAttributes.uv2      = new Vector2(gridOverlayU, 0f);
                vertexAttributes.Advance();

                vertexAttributes.position = _innerVertexPositions[edge];
                vertexAttributes.normal   = faceNormal;
                vertexAttributes.uv1      = AdjustSurfaceUV(_faceInnerEdgeUVs[edge], _faceTerrainIndices[face]);
                vertexAttributes.uv2      = new Vector2(gridOverlayU, 0.5f);
                vertexAttributes.Advance();
            },
                                                                        (Topology.Face face, DynamicMesh.IIndexedVertexAttributes vertexAttributes) =>
            {
                vertexAttributes.position = _facePositions[face];
                vertexAttributes.normal   = _faceNormals[face];
                vertexAttributes.uv1      = AdjustSurfaceUV(_faceCenterUVs[face], _faceTerrainIndices[face]);
                vertexAttributes.uv2      = new Vector2(GetGridOverlayU(false, _faceSeenStates[face], _faceSightCounts[face]), 1f);
                vertexAttributes.Advance();
            });

            _dynamicMesh = DynamicMesh.Create(
                _topology.enumerableInternalFaces,
                DynamicMesh.VertexAttributes.Position |
                DynamicMesh.VertexAttributes.Normal |
                DynamicMesh.VertexAttributes.UV1 |
                DynamicMesh.VertexAttributes.UV2,
                triangulation);

            foreach (var mesh in _dynamicMesh.submeshes)
            {
                var meshObject = Instantiate(planetMeshPrefab);
                meshObject.mesh = mesh;
                meshObject.transform.SetParent(planetMeshes, false);
            }

            _faceUnits = new Transform[_topology.faces.Count].AsFaceAttribute();
            for (int i = 0; i < unitCount; ++i)
            {
                Topology.Face face;
                do
                {
                    face = _topology.internalFaces[_random.Index(_topology.internalFaces.Count)];
                } while (_faceTerrainIndices[face] == 1 || _faceUnits[face] != null);

                var unit = Instantiate(unitPrefab);
                unit.SetParent(units, false);
                unit.transform.position = _facePositions[face] + _faceNormals[face] * 0.15f;
                _faceUnits[face]        = unit;

                RevealUnitVicinity(face);
            }
            _dynamicMesh.RebuildMesh(DynamicMesh.VertexAttributes.UV2);
        }
Esempio n. 9
0
        public void StartNewGame()
        {
            DestroyOldGame();

            Vector3[] vertexPositionsArray;

            if (squaresToggle.isOn)
            {
                IntVector2 boardSize;
                if (smallToggle.isOn)
                {
                    boardSize = new IntVector2(9, 9);
                }
                else if (mediumToggle.isOn)
                {
                    boardSize = new IntVector2(13, 13);
                }
                else
                {
                    boardSize = new IntVector2(19, 19);
                }
                _surface         = RectangularQuadGrid.Create(Vector2.right, Vector2.up, Vector3.zero, Quaternion.identity, false, false, boardSize);
                _topology        = ((RectangularQuadGrid)_surface).CreateManifold(out vertexPositionsArray);
                _vertexPositions = PositionalVertexAttribute.Create(_surface, vertexPositionsArray);
            }
            else if (hexesToggle.isOn)
            {
                IntVector2 boardSize;
                if (smallToggle.isOn)
                {
                    boardSize = new IntVector2(9, 9);
                }
                else if (mediumToggle.isOn)
                {
                    boardSize = new IntVector2(13, 13);
                }
                else
                {
                    boardSize = new IntVector2(19, 19);
                }
                _surface = RectangularHexGrid.Create(
                    HexGridDescriptor.CreateCornerUp(true, HexGridAxisStyles.StaggeredSymmetric),
                    Vector3.zero, Quaternion.identity,
                    false, false,
                    boardSize);
                _topology        = ((RectangularHexGrid)_surface).CreateManifold(out vertexPositionsArray);
                _vertexPositions = PositionalVertexAttribute.Create(_surface, vertexPositionsArray);
            }
            else
            {
                IntVector2 boardSize;
                if (smallToggle.isOn)
                {
                    boardSize = new IntVector2(9, 9);
                }
                else if (mediumToggle.isOn)
                {
                    boardSize = new IntVector2(13, 13);
                }
                else
                {
                    boardSize = new IntVector2(19, 19);
                }
                _surface = RectangularHexGrid.Create(
                    HexGridDescriptor.CreateCornerUp(true, HexGridAxisStyles.StaggeredSymmetric),
                    Vector3.zero, Quaternion.identity,
                    false, false,
                    boardSize);
                _topology        = ((RectangularHexGrid)_surface).CreateManifold(out vertexPositionsArray);
                _vertexPositions = PositionalVertexAttribute.Create(_surface, vertexPositionsArray);

                var regularityWeight = 0.5f;
                var equalAreaWeight  = 1f - regularityWeight;

                var regularityRelaxedVertexPositions = new Vector3[_topology.vertices.Count].AsVertexAttribute();
                var equalAreaRelaxedVertexPositions  = new Vector3[_topology.vertices.Count].AsVertexAttribute();
                var relaxedVertexPositions           = regularityRelaxedVertexPositions;
                var faceCentroids = PositionalFaceAttribute.Create(_surface, _topology.internalFaces.Count);
                var vertexAreas   = new float[_topology.vertices.Count].AsVertexAttribute();

                FaceAttributeUtility.CalculateFaceCentroidsFromVertexPositions(_topology.internalFaces, _vertexPositions, faceCentroids);
                VertexAttributeUtility.CalculateVertexAreasFromVertexPositionsAndFaceCentroids(_topology.vertices, _vertexPositions, faceCentroids, vertexAreas);

                var totalArea = 0f;
                foreach (var vertexArea in vertexAreas)
                {
                    totalArea += vertexArea;
                }

                Func <float> relaxIterationFunction = () =>
                {
                    PlanarManifoldUtility.RelaxVertexPositionsForRegularity(_topology, _vertexPositions, true, regularityRelaxedVertexPositions);
                    PlanarManifoldUtility.RelaxVertexPositionsForEqualArea(_topology, _vertexPositions, totalArea, true, equalAreaRelaxedVertexPositions, faceCentroids, vertexAreas);
                    for (int i = 0; i < relaxedVertexPositions.Count; ++i)
                    {
                        relaxedVertexPositions[i] = regularityRelaxedVertexPositions[i] * regularityWeight + equalAreaRelaxedVertexPositions[i] * equalAreaWeight;
                    }
                    var relaxationAmount = PlanarManifoldUtility.CalculateRelaxationAmount(_vertexPositions, relaxedVertexPositions);
                    for (int i = 0; i < _vertexPositions.Count; ++i)
                    {
                        _vertexPositions[i] = relaxedVertexPositions[i];
                    }
                    return(relaxationAmount);
                };

                Func <bool> repairFunction = () =>
                {
                    return(PlanarManifoldUtility.ValidateAndRepair(_topology, _surface.normal, _vertexPositions, 0.5f, true));
                };

                Action relaxationLoopFunction = TopologyRandomizer.CreateRelaxationLoopFunction(20, 20, 0.95f, relaxIterationFunction, repairFunction);

                TopologyRandomizer.Randomize(
                    _topology, 1, 0.1f,
                    3, 3, 5, 7, true,
                    _random,
                    relaxationLoopFunction);
            }

            _facePositions = PositionalFaceAttribute.Create(_surface, _topology.internalFaces.Count);
            FaceAttributeUtility.CalculateFaceCentroidsFromVertexPositions(_topology.internalFaces, _vertexPositions, _facePositions);

            _innerAngleBisectors = EdgeAttributeUtility.CalculateFaceEdgeBisectorsFromVertexPositions(_topology.internalFaces, PlanarSurface.Create(Vector3.zero, Quaternion.identity), _vertexPositions);

            _faceBoardStates = new BoardState[_topology.internalFaces.Count].AsFaceAttribute();

            foreach (var face in _topology.internalFaces)
            {
                _faceBoardStates[face] = BoardState.Empty;
            }

            _facePieces = new Transform[_topology.internalFaces.Count].AsFaceAttribute();

            _partitioning        = UniversalFaceSpatialPartitioning.Create(_surface, _topology, _vertexPositions);
            _picker.partitioning = _partitioning;
            _picker.enabled      = true;

            var centerVertexNormal = _surface.normal.normalized;

            var triangulation = new SeparatedFacesUmbrellaTriangulation(2,
                                                                        (Topology.FaceEdge edge, DynamicMesh.IIndexedVertexAttributes vertexAttributes) =>
            {
                vertexAttributes.position = _vertexPositions[edge];
                vertexAttributes.normal   = (_vertexPositions[edge] + _surface.normal * 5f - _facePositions[edge.nearFace]).normalized;
                vertexAttributes.uv       = new Vector2(0.25f, 0f);
                vertexAttributes.Advance();

                vertexAttributes.position = _vertexPositions[edge] + _innerAngleBisectors[edge] * 0.05f;
                vertexAttributes.normal   = (vertexAttributes.position + _surface.normal * 5f - _facePositions[edge.nearFace]).normalized;
                vertexAttributes.uv       = new Vector2(0.25f, 0.5f);
                vertexAttributes.Advance();
            },
                                                                        (Topology.Face face, DynamicMesh.IIndexedVertexAttributes vertexAttributes) =>
            {
                vertexAttributes.position = _facePositions[face];
                vertexAttributes.normal   = centerVertexNormal;
                vertexAttributes.uv       = new Vector2(0.25f, 1f);
                vertexAttributes.Advance();
            });

            _dynamicMesh = DynamicMesh.Create(
                _topology.enumerableInternalFaces,
                DynamicMesh.VertexAttributes.Position |
                DynamicMesh.VertexAttributes.Normal |
                DynamicMesh.VertexAttributes.UV,
                triangulation);

            foreach (var mesh in _dynamicMesh.submeshes)
            {
                var meshObject = Instantiate(meshFilterRendererPrefab);
                meshObject.mesh = mesh;
                meshObject.transform.SetParent(gameBoardMeshes);
            }

            _gameBoardBounds = new Bounds(Vector3.zero, Vector3.zero);
            foreach (var vertex in _topology.vertices)
            {
                _gameBoardBounds.Encapsulate(_vertexPositions[vertex]);
            }

            AdjustCamera();

            var pickerCollider = GetComponent <BoxCollider>();

            pickerCollider.center = _gameBoardBounds.center;
            pickerCollider.size   = _gameBoardBounds.size;

            _whiteCount = 0;
            _blackCount = 0;
            _moveCount  = 0;

            whiteCountText.text = _whiteCount.ToString();
            blackCountText.text = _blackCount.ToString();

            _gameActive = true;
            _turn       = BoardState.Black;
        }
Esempio n. 10
0
        /// <summary>
        /// Calculates the spherical surface area around each vertex that is closest to that vertex, based on face centroid angles of each edge.
        /// </summary>
        /// <param name="vertices">The collection of vertices whose areas are to be calculated.</param>
        /// <param name="surface">The surface describing the overall shape of the spherical manifold.</param>
        /// <param name="faceCentroidAngles">The centroid angles, in radians, of the face edges.</param>
        /// <param name="vertexAreas">A pre-allocated collection in which the surrounding surface areas will be stored.</param>
        /// <returns>The surrounding spherical surface areas of the vertices.</returns>
        /// <seealso cref="O:MakeIt.Tile.EdgeAttributeUtility.CalculateSphericalFaceCentroidAnglesFromFaceCentroids"/>
        public static IVertexAttribute <float> CalculateSphericalVertexAreasFromFaceCentroidAngles(Topology.VerticesIndexer vertices, SphericalSurface surface, IEdgeAttribute <float> faceCentroidAngles, IVertexAttribute <float> vertexAreas)
        {
            var radiusSquared = surface.radius * surface.radius;

            foreach (var vertex in vertices)
            {
                float angleSum = 0f;
                foreach (var edge in vertex.edges)
                {
                    angleSum += faceCentroidAngles[edge];
                }
                vertexAreas[vertex] = (angleSum - Mathf.PI) * radiusSquared;
            }

            return(vertexAreas);
        }
Esempio n. 11
0
 /// <summary>
 /// Calculates the spherical surface area around each vertex that is closest to that vertex, based on face centroid angles of each edge.
 /// </summary>
 /// <param name="vertices">The collection of vertices whose areas are to be calculated.</param>
 /// <param name="surface">The surface describing the overall shape of the spherical manifold.</param>
 /// <param name="faceCentroidAngles">The centroid angles, in radians, of the face edges.</param>
 /// <returns>The surrounding spherical surface areas of the vertices.</returns>
 /// <seealso cref="O:MakeIt.Tile.EdgeAttributeUtility.CalculateSphericalFaceCentroidAnglesFromFaceCentroids"/>
 public static IVertexAttribute <float> CalculateSphericalVertexAreasFromFaceCentroidAngles(Topology.VerticesIndexer vertices, SphericalSurface surface, IEdgeAttribute <float> faceCentroidAngles)
 {
     return(CalculateSphericalVertexAreasFromFaceCentroidAngles(vertices, surface, faceCentroidAngles, new float[vertices.Count].AsVertexAttribute()));
 }
        /// <summary>
        /// Attempts to move the positions of vertices such that they have roughly uniform density, with a bias towards also making sure that the surface areas of the faces also become more uniform.
        /// </summary>
        /// <param name="surface">The spherical surface describing the overall shape of the manifold.</param>
        /// <param name="topology">The topology to relax.</param>
        /// <param name="vertexPositions">The original positions of the vertices to relax.</param>
        /// <param name="lockBoundaryPositions">Indicates that vertices with an external neighboring face should not have their positions altered.</param>
        /// <param name="relaxedVertexPositions">A pre-allocated collection in which the relaxed vertex positions will be stored.  Should not be the same collection as <paramref name="vertexPositions"/>.</param>
        /// <param name="faceCentroids">A pre-allocated collection in which the intermediate face centroid positions will be stored.</param>
        /// <param name="vertexAreas">A pre-allocated collection in which the intermediate nearby surface areas of vertices will be stored.</param>
        /// <param name="faceCentroidAngles">A pre-allocated collection in which the intermediate face centroid angles will be stored.</param>
        /// <returns>The relaxed vertex positions.</returns>
        public static IVertexAttribute <Vector3> RelaxVertexPositionsForEqualArea(SphericalSurface surface, Topology topology, IVertexAttribute <Vector3> vertexPositions, bool lockBoundaryPositions, IVertexAttribute <Vector3> relaxedVertexPositions, IFaceAttribute <Vector3> faceCentroids, IEdgeAttribute <float> faceCentroidAngles, IVertexAttribute <float> vertexAreas)
        {
            var idealArea = surface.radius * surface.radius * 4f * Mathf.PI / topology.vertices.Count;

            FaceAttributeUtility.CalculateSphericalFaceCentroidsFromVertexPositions(topology.internalFaces, surface, vertexPositions, faceCentroids);
            EdgeAttributeUtility.CalculateSphericalFaceCentroidAnglesFromFaceCentroids(topology.faceEdges, surface, faceCentroids, faceCentroidAngles);
            VertexAttributeUtility.CalculateSphericalVertexAreasFromFaceCentroidAngles(topology.vertices, surface, faceCentroidAngles, vertexAreas);

            for (int i = 0; i < topology.vertices.Count; ++i)
            {
                relaxedVertexPositions[i] = new Vector3(0f, 0f, 0f);
            }

            foreach (var vertex in topology.vertices)
            {
                var multiplier = Mathf.Sqrt(idealArea / vertexAreas[vertex]);
                foreach (var edge in vertex.edges)
                {
                    var neighborVertex         = edge.vertex;
                    var neighborRelativeCenter = vertexPositions[edge.twin];
                    relaxedVertexPositions[neighborVertex] += (vertexPositions[neighborVertex] - neighborRelativeCenter) * multiplier + neighborRelativeCenter;
                }
            }

            foreach (var vertex in topology.vertices)
            {
                if (!lockBoundaryPositions || !vertex.hasExternalFaceNeighbor)
                {
                    relaxedVertexPositions[vertex] = relaxedVertexPositions[vertex].WithMagnitude(surface.radius);
                }
                else
                {
                    relaxedVertexPositions[vertex] = vertexPositions[vertex];
                }
            }

            return(relaxedVertexPositions);
        }