Example #1
0
        /// <summary>
        /// Setups, creates, and builds the base hexagon mesh that always fills an entire tile.
        /// </summary>
        public Mesh BaseHexagon(HexMetrics metrics, HexMap hexMap, int column, int row, Mesh recycleMesh = null)
        {
            ClearAndSetup("Hexagon Tile", recycleMesh);

            Vector3 center = HexUtils.PositionFromCoordinates(column, row, metrics.tileSize);

            float centerHeight = metrics.XZPositionToHeight(center);

            float[] cornerHeights = new float[6];
            foreach (var corner in HexCornerUtils.AllCorners())
            {
                Vector3 vertex = HexUtils.CornerPosition((int)corner) * metrics.tileSize;
                cornerHeights[corner.GetInt()] = metrics.XZPositionToHeight(center + vertex);
            }

            #region Base Hexagon


            // Add vertex data for each corner first in order to reduce redundancy (18 vertices -> 7)
            // Not making triangles yet
            foreach (HexCorner corner in HexCornerUtils.AllCorners())
            {
                // Vertice w/ height
                Vector3 cornerPoint  = SpokePoint(metrics, corner, 1, centerHeight, cornerHeights);
                float   vertexHeight = centerHeight + (cornerHeights[corner.GetInt()] - centerHeight) * 1;
                AddHexPointData(metrics, cornerPoint, center, Color.white, vertexHeight);
            }

            // Add the center point last just so that we can use the HexCorner enums as indexes and the center is @ 6
            int Center = 6;             // just for readability
            // UV
            uvs.Add(metrics.XZPositionToUV(center));

            // Vertice
            Vector3 cenVertex = new Vector3(0, centerHeight * metrics.mapHeight, 0);
            vertices.Add(cenVertex);

            // Color
            colors.Add(Color.white);

            // Gradient
            uvs2.Add(new Vector2(centerHeight, 0));

            // Make triangles
            foreach (HexCorner corner in HexCornerUtils.AllCorners())
            {
                triangles.Add((int)corner.Next());                 // Next first because of normals
                triangles.Add((int)corner);
                triangles.Add(Center);
            }

            #endregion


            return(Build());
        }
Example #2
0
        public Mesh ElevatedTileHexagon(HexMetrics metrics, HexMap hexMap, int column, int row, Mesh recycleMesh = null)
        {
            ClearAndSetup("Hexagon Tile With Elevation", recycleMesh);

            Vector3 center = HexUtils.PositionFromCoordinates(column, row, metrics.tileSize);

            int elevation = hexMap.GetElevationAt(column, row);

            float elevationHeight = metrics.elevationStepHeight * elevation;

            Color baseColor = hexMap.tileset.GetColorForElevation(elevation, metrics.maxElevation);

            float centerHeight = metrics.XZPositionToHeight(center);

            float[] cornerHeights = new float[6];
            foreach (var corner in HexCornerUtils.AllCorners())
            {
                Vector3 vertex = HexUtils.CornerPosition((int)corner) * metrics.tileSize;
                cornerHeights[corner.GetInt()] = metrics.XZPositionToHeight(center + vertex);
            }

            #region Base Hexagon

            float baseHexagonPercentage = metrics.tileInnerRadiusPercent;

            // Add vertex data for each corner first in order to reduce redundancy (18 vertices -> 7)
            // Not making triangles yet
            foreach (HexCorner corner in HexCornerUtils.AllCorners())
            {
                // Vertice w/ height
                //Vector3 cornerPoint = SpokePoint(metrics, corner, baseHexagonPercentage, centerHeight, cornerHeights);
                // Base the height of the 'spokes' on the straight line from the center out to the corner of the whole tile
                Vector3 cornerVertex = HexUtils.CornerPosition((int)corner) * metrics.tileSize * baseHexagonPercentage;

                float projectedSpokeHeight = (cornerHeights[corner.GetInt()] - centerHeight)
                                             * baseHexagonPercentage;
                float   vertexHeight    = centerHeight + projectedSpokeHeight;
                Vector3 cornerPoint     = cornerVertex + Vector3.up * (vertexHeight * metrics.mapHeight + elevationHeight);
                float   textureGradient = vertexHeight;
                AddHexPointData(metrics, cornerPoint, center, baseColor, textureGradient);
            }

            // Add the center point last just so that we can use the HexCorner enums as indexes and the center is @ 6
            int Center = 6;             // just for readability
            // UV
            uvs.Add(metrics.XZPositionToUV(center));

            // Vertice
            Vector3 centerVertex = new Vector3(0, centerHeight * metrics.mapHeight + elevationHeight, 0);
            vertices.Add(centerVertex);

            // Color
            colors.Add(baseColor);

            // Gradient
            uvs2.Add(new Vector2(centerHeight, 0));

            // Make triangles
            foreach (HexCorner corner in HexCornerUtils.AllCorners())
            {
                triangles.Add((int)corner.Next());                 // Next first because of normals
                triangles.Add((int)corner);
                triangles.Add(Center);
            }

            #endregion

            // The starting index of the points for the outer ring
            int ringStartIndex = vertices.Count;             // should be 7 here

            // ----------Add another ring to the hexagon
            #region First Ring

            float firstRingPercentage = metrics.tileOuterRadiusPercent;

            // Add vertex data for each outside corner
            // Not making triangles yet
            // Add three points for each corner: the actual outside corner and then the two bridge points
            foreach (HexCorner corner in HexCornerUtils.AllCorners())
            {
                HexDirection direction = corner.GetDirection();

                float theta = HexUtils.CornerAngle((int)corner);

                //// We need to account for the three walls connecting to this corner:
                //// the wall on this hex going left,
                //// the wall on this hex going right,
                //// and the wall adjacent to this hex running out and away
                //bool leftWall = hexMap.IsWallAt(column, row, corner.GetDirection());
                //bool rightWall = hexMap.IsWallAt(column, row, corner.GetDirection().Last());
                //// move to the hex left of the given corner, turn two directions CW and check that wall
                //bool awayWall = hexMap.IsWallAt(HexUtils.MoveFrom(column, row, corner.GetDirection()), corner.GetDirection().Last2());



                // -------Actual Corner---------- -
                {
                    Vector3 cornerVertex = HexUtils.CornerPosition((int)corner) * metrics.tileSize * firstRingPercentage;

                    float nextNeighborElevationHeight = metrics.elevationStepHeight *
                                                        hexMap.GetElevationAt(HexUtils.MoveFrom(column, row, direction));
                    float lastNeighborElevationHeight = metrics.elevationStepHeight *
                                                        hexMap.GetElevationAt(HexUtils.MoveFrom(column, row, direction.Last()));
                    float heightModFromElevation =
                        (elevationHeight + nextNeighborElevationHeight + lastNeighborElevationHeight) * 0.33f;

                    float projectedSpokeHeight = (cornerHeights[corner.GetInt()] - centerHeight)
                                                 * firstRingPercentage;
                    float   vertexHeight = centerHeight + projectedSpokeHeight;
                    Vector3 cornerPoint  = cornerVertex +
                                           Vector3.up * (vertexHeight * metrics.mapHeight + heightModFromElevation);
                    float textureGradient = vertexHeight;

                    bool  isWall     = hexMap.IsWallAt(column, row, direction.Last());
                    Color slopeColor = baseColor;
                    if (isWall)
                    {
                        slopeColor = hexMap.tileset.steepSlopeColor;
                    }

                    AddHexPointData(metrics, cornerPoint, center, slopeColor, textureGradient);
                }

                //// ------- CCW Bridge Point -----------
                {
                    var fromCorner       = corner;
                    var towardCorner     = corner.Next();
                    var bridgePercentage = metrics.tileInnerRadiusPercent;

                    //Vector3 bridgePoint = BridgePoint(metrics, corner, corner.Next(), firstRingPercentage,
                    //	metrics.tileInnerRadiusPercent, centerVertex, cornerHeights);

                    float nextNeighborElevationHeight = metrics.elevationStepHeight *
                                                        hexMap.GetElevationAt(HexUtils.MoveFrom(column, row, direction));
                    float heightModFromElevation =
                        (elevationHeight + nextNeighborElevationHeight) * 0.5f;


                    Vector3 cornerVertex = HexUtils.CornerPosition((int)fromCorner) * metrics.tileSize;
                    cornerVertex = cornerVertex +
                                   Vector3.up * (cornerHeights[fromCorner.GetInt()] * metrics.mapHeight + heightModFromElevation);

                    Vector3 nextCornerPoint = HexUtils.CornerPosition(towardCorner.GetInt()) * metrics.tileSize;
                    nextCornerPoint = nextCornerPoint +
                                      Vector3.up * (cornerHeights[towardCorner.GetInt()] * metrics.mapHeight + heightModFromElevation);

                    Vector3 vector      = nextCornerPoint - cornerVertex;
                    float   bridgeMod   = 0.5f * (1f - bridgePercentage);
                    Vector3 bridgePoint = cornerVertex + vector * bridgeMod;

                    vector      = centerVertex - bridgePoint;
                    bridgePoint = bridgePoint + vector * (1f - firstRingPercentage);

                    bool  isWall     = hexMap.IsWallAt(column, row, direction);
                    Color slopeColor = baseColor;
                    if (isWall)
                    {
                        slopeColor = hexMap.tileset.steepSlopeColor;
                    }

                    AddHexPointData(metrics, bridgePoint, center, slopeColor, cornerHeights[corner.GetInt()]);
                }

                //// ------- CW Bridge Point -----------
                {
                    //Vector3 bridgePoint = BridgePoint(metrics, corner, corner.Last(), firstRingPercentage,
                    //	metrics.tileInnerRadiusPercent, centerVertex, cornerHeights);

                    var fromCorner       = corner;
                    var towardCorner     = corner.Last();
                    var bridgePercentage = metrics.tileInnerRadiusPercent;

                    //Vector3 bridgePoint = BridgePoint(metrics, corner, corner.Next(), firstRingPercentage,
                    //	metrics.tileInnerRadiusPercent, centerVertex, cornerHeights);

                    float neighborElevationHeight = metrics.elevationStepHeight *
                                                    hexMap.GetElevationAt(HexUtils.MoveFrom(column, row, direction.Last()));
                    float heightModFromElevation =
                        (elevationHeight + neighborElevationHeight) * 0.5f;

                    Vector3 cornerVertex = HexUtils.CornerPosition((int)fromCorner) * metrics.tileSize;
                    cornerVertex = cornerVertex +
                                   Vector3.up * (cornerHeights[fromCorner.GetInt()] * metrics.mapHeight + heightModFromElevation);

                    Vector3 nextCornerPoint = HexUtils.CornerPosition(towardCorner.GetInt()) * metrics.tileSize;
                    nextCornerPoint = nextCornerPoint + Vector3.up * (cornerHeights[towardCorner.GetInt()] * metrics.mapHeight + heightModFromElevation);

                    Vector3 vector      = nextCornerPoint - cornerVertex;
                    float   bridgeMod   = 0.5f * (1f - bridgePercentage);
                    Vector3 bridgePoint = cornerVertex + vector * bridgeMod;

                    vector      = centerVertex - bridgePoint;
                    bridgePoint = bridgePoint + vector * (1f - firstRingPercentage);

                    bool  isWall     = hexMap.IsWallAt(column, row, direction.Last());
                    Color slopeColor = baseColor;
                    if (isWall)
                    {
                        slopeColor = hexMap.tileset.steepSlopeColor;
                    }
                    AddHexPointData(metrics, bridgePoint, center, slopeColor, cornerHeights[corner.GetInt()]);
                }
            }

            // Make triangles, accounting for one corner and one side at a time

            // we actually need quads, so pairs of triangles
            foreach (HexCorner corner in HexCornerUtils.AllCorners())
            {
                // inside point is [corner], outside point is [corner * 3 + ORStart]
                int outerCorner = (int)corner * 3 + ringStartIndex + 0;
                // left bridge point is [corner * 3 + ORStart + 1], right bridge point is [corner * 3 + ORStart + 2]
                int rightBridgePoint = (int)corner * 3 + ringStartIndex + 2;
                int leftBridgePoint  = (int)corner * 3 + ringStartIndex + 1;
                // corner.Next() is the point CCW
                int nextRightBridgePoint = (int)corner.Next() * 3 + ringStartIndex + 2;

                // first half of the quad
                triangles.Add((int)corner);
                triangles.Add((int)corner.Next());
                triangles.Add(nextRightBridgePoint);

                // second half of the quad
                triangles.Add(nextRightBridgePoint);
                triangles.Add(leftBridgePoint);
                triangles.Add((int)corner);

                // span from the quad to the corner with a quad
                triangles.Add(leftBridgePoint);
                triangles.Add(outerCorner);
                triangles.Add((int)corner);

                // second part of corner span
                triangles.Add(rightBridgePoint);
                triangles.Add((int)corner);
                triangles.Add(outerCorner);
            }

            #endregion



            return(Build());
        }