System.Collections.Generic.List.Add(Vector3)

Here are the examples of the csharp api System.Collections.Generic.List.Add(Vector3) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

1597 Examples 7

19 View Source File : Path.cs
License : MIT License
Project Creator : Alan-FGR

public List<Vector3> SubdivideEvenly(int divisions)
        {
            List<Vector3> verts = new List<Vector3>();

            float length = GetLength();

            float deltaLength = length / divisions + 0.001f;
            float t = 0.000f;

            // we always start at the first control point
            Vector2 start = ControlPoints[0];
            Vector2 end = GetPosition(t);

            // increment t until we are at half the distance
            while (deltaLength * 0.5f >= Vector2.Distance(start, end))
            {
                end = GetPosition(t);
                t += 0.0001f;

                if (t >= 1f)
                    break;
            }

            start = end;

            // for each box
            for (int i = 1; i < divisions; i++)
            {
                Vector2 normal = GetPositionNormal(t);
                float angle = (float)Math.Atan2(normal.Y, normal.X);

                verts.Add(new Vector3(end, angle));

                // until we reach the correct distance down the curve
                while (deltaLength >= Vector2.Distance(start, end))
                {
                    end = GetPosition(t);
                    t += 0.00001f;

                    if (t >= 1f)
                        break;
                }
                if (t >= 1f)
                    break;

                start = end;
            }
            return verts;
        }

19 View Source File : LineMeshModifier.cs
License : MIT License
Project Creator : alen-smajic

private void AddCurrentVertex(Vector3 vertexPosition, float dist, Vector3 normal, MeshData md, float endLeft = 0, float endRight = 0)
		{
			var triIndexStart = md.Vertices.Count;
			var extrude = normal;
			if (endLeft != 0)
			{
				extrude -= (normal.Perpendicular() * endLeft);
			}

			var vert = vertexPosition + extrude * _scaledWidth;
			_vertexList.Add(vert);
			_normalList.Add(Constants.Math.Vector3Up);
			_uvList.Add(new Vector2(1, dist));
			_tangentList.Add(normal.Perpendicular() * -1);

			_index3 = triIndexStart + _vertexList.Count - 1;
			if (_index1 >= triIndexStart && _index2 >= triIndexStart)
			{
				_triangleList.Add(_index1);
				_triangleList.Add(_index3);
				_triangleList.Add(_index2);
				md.Edges.Add(triIndexStart + _vertexList.Count - 1);
				md.Edges.Add(triIndexStart + _vertexList.Count - 3);
			}

			_index1 = _index2;
			_index2 = _index3;


			extrude = normal * -1;
			if (endRight != 0)
			{
				extrude -= normal.Perpendicular() * endRight;
			}

			_vertexList.Add(vertexPosition + extrude * _scaledWidth);
			_normalList.Add(Constants.Math.Vector3Up);
			_uvList.Add(new Vector2(0, dist));
			_tangentList.Add(normal.Perpendicular() * -1);

			_index3 = triIndexStart + _vertexList.Count - 1;
			if (_index1 >= triIndexStart && _index2 >= triIndexStart)
			{
				_triangleList.Add(_index1);
				_triangleList.Add(_index2);
				_triangleList.Add(_index3);
				md.Edges.Add(triIndexStart + _vertexList.Count - 3);
				md.Edges.Add(triIndexStart + _vertexList.Count - 1);
			}

			_index1 = _index2;
			_index2 = _index3;
		}

19 View Source File : BoundingBox.cs
License : GNU General Public License v3.0
Project Creator : ACEmulator

public void BuildVerts()
        {
            Verts = new List<Vector3>();
            /*Verts.Add(new Vector3(Mins.X, Mins.Y, Maxs.Z));   // Front NW
            Verts.Add(new Vector3(Maxs.X, Mins.Y, Maxs.Z));   // Front NE
            Verts.Add(new Vector3(Maxs.X, Mins.Y, Mins.Z));   // Front SE
            Verts.Add(new Vector3(Mins.X, Mins.Y, Mins.Z));   // Front SW
            Verts.Add(new Vector3(Maxs.X, Maxs.Y, Maxs.Z));   // Back NE
            Verts.Add(new Vector3(Mins.X, Maxs.Y, Maxs.Z));   // Back NW
            Verts.Add(new Vector3(Mins.X, Maxs.Y, Mins.Z));   // Back SW
            Verts.Add(new Vector3(Maxs.X, Maxs.Y, Mins.Z));   // Back SE*/

            Verts.Add(new Vector3(Maxs.X, Maxs.Y, Maxs.Z));   // Front NW
            Verts.Add(new Vector3(Mins.X, Maxs.Y, Maxs.Z));   // Front NE
            Verts.Add(new Vector3(Mins.X, Maxs.Y, Mins.Z));   // Front SE
            Verts.Add(new Vector3(Maxs.X, Maxs.Y, Mins.Z));   // Front SW
            Verts.Add(new Vector3(Mins.X, Mins.Y, Maxs.Z));   // Back NE
            Verts.Add(new Vector3(Maxs.X, Mins.Y, Maxs.Z));   // Back NW
            Verts.Add(new Vector3(Maxs.X, Mins.Y, Mins.Z));   // Back SW
            Verts.Add(new Vector3(Mins.X, Mins.Y, Mins.Z));   // Back SE
        }

19 View Source File : MeshUtility.cs
License : Apache License 2.0
Project Creator : aivclab

public static Mesh GenerateSpotlightCircleMesh(Camera main) {
      if (!main) {
        return null;
      }

      const int circle_segment_count = 64;
      const int circle_vertex_count = circle_segment_count + 2;
      const int circle_index_count = circle_segment_count * 3;
      const Single segment_width = Mathf.PI * 2f / circle_segment_count;

      var circle = new Mesh();
      var vertices = new List<Vector3>(capacity : circle_vertex_count);
      var indices = new int[circle_index_count];

      var angle = 0f;
      vertices.Add(item : Vector3.zero);
      for (var i = 1; i < circle_vertex_count; ++i) {
        vertices.Add(item : new Vector3(x : Mathf.Cos(f : angle), y : Mathf.Sin(f : angle), 0f));
        angle -= segment_width;
        if (i > 1) {
          var j = (i - 2) * 3;
          indices[j + 0] = 0;
          indices[j + 1] = i - 1;
          indices[j + 2] = i;
        }
      }

      circle.SetVertices(inVertices : vertices);
      circle.SetIndices(indices : indices, topology : MeshTopology.Triangles, 0);


      //var x1 = Mathf.Tan(main.fieldOfView * 0.5f * Mathf.Deg2Rad) * main.aspect * main.nearClipPlane;
      //var y1 = Mathf.Tan(main.fieldOfView * 0.5f * Mathf.Deg2Rad) * main.nearClipPlane;
      //var z1 = main.nearClipPlane;

      //normals
      var normals_list = new List<Vector3>();
      for (var i = 0; i < vertices.Count; i++) {
        normals_list.Add(item : Vector3.forward);
      }

      circle.SetNormals(inNormals : normals_list);
      //circle.RecalculateNormals();
      circle.RecalculateBounds();
      //circle.Optimize();
      return circle;
    }

19 View Source File : ObjLoader.cs
License : The Unlicense
Project Creator : aeroson

int FindOrAddObjVertex(ref string faceParamater, ref Vector3 vertex, ref Vector2 texCoord, ref Vector3 normal)
        {
            int index;
            if (objFaceToMeshIndicie.TryGetValue(faceParamater, out index)) {
                return index;
            } else {

                verticesMesh.Add(vertex);
                uvsMesh.Add(texCoord);
                normalsMesh.Add(normal);

                index = verticesMesh.Count - 1;
                objFaceToMeshIndicie[faceParamater]=index;

                return index;
            }
        }

19 View Source File : CharacterCapsule.cs
License : MIT License
Project Creator : absurd-joy

void Update ()
	{
	    if (_character == null)
	    {
	        _character = GetComponentInParent<CharacterController>();
	        if (_character == null)
	        {
	            return;
	        }
	    }

	    if (_height == _character.height 
            && _radius == _character.radius 
            && _subdivisionU == SubdivisionsU 
            && _subdivisionV == SubdivisionsV)
	    {
	        return;
	    }

        _height = _character.height;
	    _radius = _character.radius;
	    _subdivisionU = SubdivisionsU;
	    _subdivisionV = SubdivisionsV;

        List<Vector3> verts = new List<Vector3>();

        var vector = new Vector3(1,0,0);

        // Generate the mesh
        var topOffset = new Vector3(0, _height/2.0f - _radius, 0);
        var bottomOffset = new Vector3(0, _radius - _height/2.0f, 0);

        // Add all the necessary vertices
        verts.Add(new Vector3(0, _height/2.0f, 0));

	    for (int u = SubdivisionsU - 1; u >= 0; u--)
	    {
	        float uf = (float) u / (float) SubdivisionsU;
            for (int v = 0; v < SubdivisionsV; v++)
            {
                float vf = (float) v / (float) SubdivisionsV;
                var q = Quaternion.Euler(0, vf * 360.0f, uf * 90.0f);
                var vert = q * vector;
                vert *= _radius;
                var v1 = vert + topOffset;
                verts.Add(v1);
	        }
        }

	    for (int u = 0; u < SubdivisionsU; u++)
	    {
            float uf = (float)u / (float)SubdivisionsU;
	        for (int v = 0; v < SubdivisionsV; v++)
	        {
	            float vf = (float)v / (float)SubdivisionsV;
	            var q = Quaternion.Euler(0, vf * 360.0f + 180.0f, uf * 90.0f);
	            var vert = q * vector;
	            vert *= _radius;
	            var v2 = bottomOffset - vert;
	            verts.Add(v2);
	        }
	    }
	    verts.Add(new Vector3(0, -_height / 2.0f, 0));


        // Setup all the triangles

        List<int> tris = new List<int>();
	    int index;
	    int i;

        // top cap
	    for (int v = 0; v < SubdivisionsV; v++)
	    {
	        i = 0;
	        tris.Add(i);
	        tris.Add(v);
	        tris.Add(v+1);
	    }
	    tris.Add(0);
        tris.Add(SubdivisionsV);
	    tris.Add(1);

        // top hemisphere
        for (int u = 0; u < SubdivisionsU - 1; u++)
	    {
	        index = u * SubdivisionsV + 1;
	        for (int v = 0; v < SubdivisionsV - 1; v++)
            {
                i = index + v;
                tris.Add(i);
                tris.Add(i + SubdivisionsV);
                tris.Add(i + 1);

                tris.Add(i + 1);
                tris.Add(i + SubdivisionsV);
                tris.Add(i + SubdivisionsV + 1);
           }
	        i = index + SubdivisionsV - 1;
	        tris.Add(i);
	        tris.Add(i + SubdivisionsV);
	        tris.Add(i + 1 - SubdivisionsV);

            tris.Add(i + 1 - SubdivisionsV);
            tris.Add(i + SubdivisionsV);
	        tris.Add(i + 1);
        }

        // center tube
        index = (SubdivisionsU - 1) * SubdivisionsV + 1;
	    for (int v = 0; v < SubdivisionsV - 1; v++)
	    {
	        i = index + v;
	        tris.Add(i);
	        tris.Add(i + SubdivisionsV);
	        tris.Add(i + 1);

	        tris.Add(i + 1);
	        tris.Add(i + SubdivisionsV);
	        tris.Add(i + SubdivisionsV + 1);
	    }
	    i = index + SubdivisionsV - 1;
	    tris.Add(i);
	    tris.Add(i + SubdivisionsV);
	    tris.Add(i + 1 - SubdivisionsV);

	    tris.Add(i + 1 - SubdivisionsV);
	    tris.Add(i + SubdivisionsV);
	    tris.Add(i + 1);

        // bottom hemisphere
        for (int u = 0; u < SubdivisionsU - 1; u++)
	    {
	        index = u * SubdivisionsV + (SubdivisionsU * SubdivisionsV) + 1;
	        for (int v = 0; v < SubdivisionsV - 1; v++)
	        {
	            i = index + v;
	            tris.Add(i);
	            tris.Add(i + SubdivisionsV);
	            tris.Add(i + 1);

	            tris.Add(i + 1);
	            tris.Add(i + SubdivisionsV);
	            tris.Add(i + SubdivisionsV + 1);
	        }
	        i = index + SubdivisionsV - 1;
	        tris.Add(i);
	        tris.Add(i + SubdivisionsV);
	        tris.Add(i + 1 - SubdivisionsV);

	        tris.Add(i + 1 - SubdivisionsV);
	        tris.Add(i + SubdivisionsV);
	        tris.Add(i + 1); 
	    }

        // bottom cap
	    var last = verts.Count - 1;
	    var lastRow = last - SubdivisionsV;
	    for (int v = 0; v < SubdivisionsV; v++)
	    {
	        i = 0;
	        tris.Add(last);
	        tris.Add(lastRow + v + 1);
	        tris.Add(lastRow + v);
	    }
	    tris.Add(last);
	    tris.Add(lastRow);
	    tris.Add(last - 1);


        _vertices = verts.ToArray();
	    _triangles = tris.ToArray();

	    _meshFilter = gameObject.GetComponent<MeshFilter>();
        _meshFilter.mesh = new Mesh();
        _meshFilter.sharedMesh.vertices = _vertices;
	    _meshFilter.sharedMesh.triangles = _triangles;
        _meshFilter.sharedMesh.RecalculateNormals();
	}

19 View Source File : MapBuilder.cs
License : MIT License
Project Creator : alen-smajic

IEnumerator WayBuilder()
    {
        float TargetCount = MapReader.ways.Count;
        Text PercentageDisplayer = InGameLoadingScreen.GetComponent<Text>();

        InGameLoadingWindow.SetActive(true);

        foreach (KeyValuePair<ulong, OsmWay> w in MapReader.ways)
        {
            // A simple loading progress logic, which returns the amount
            // of processed items divided by the total number of items.
            processed_items += 1;
            float loadingPercentage = processed_items / TargetCount * 100;

            if(loadingPercentage < 99) 
            {
                if(loadingPercentage > percentageAmount)
                {
                    percentageAmount += 1;
                    PercentageDisplayer.text = percentageAmount.ToString() + "%";
                }
            }
            else
            {
                InGameLoadingScreen.SetActive(false);
                InGameLoadingMessage.SetActive(false);
                InGameLoadingWindow.SetActive(false);
            }

            // Here we start the process of road/rail road instantiation.
            if (w.Value.PublicTransportStreet)
            {
                if (UserPreferences.PublicTransportStreets)
                {
                    inUse = bus_streets;
                }
                else
                {
                    inUse = null;
                    continue;
                }
            }
            else if (w.Value.PublicTransportRailway)
            {
                if (UserPreferences.PublicTransportRailways)
                {
                    if(!UserPreferences.Subways && !UserPreferences.Trams && !UserPreferences.Trains && !UserPreferences.Railways && !UserPreferences.LightRails)
                    {
                        inUse = public_transport_railways;
                    }
                    else if (w.Value.TransportTypes.Contains("subway"))
                    {
                        if (UserPreferences.Subways)
                        {
                            inUse = subways;
                        }
                        else
                        {
                            inUse = null;
                            continue;
                        }
                    }
                    else if (w.Value.TransportTypes.Contains("tram"))
                    {
                        if (UserPreferences.Trams)
                        {
                            inUse = trams;
                        }
                        else
                        {
                            inUse = null;
                            continue;
                        }
                    }
                    else if (w.Value.TransportTypes.Contains("train"))
                    {
                        if (UserPreferences.Trains)
                        {
                            inUse = trains;
                        }
                        else
                        {
                            inUse = null;
                            continue;
                        }
                    }
                    else if (w.Value.TransportTypes.Contains("railway"))
                    {
                        if (UserPreferences.Railways)
                        {
                            inUse = railway;
                        }
                        else
                        {
                            inUse = null;
                            continue;
                        }
                    }
                    else if (w.Value.TransportTypes.Contains("light_rail"))
                    {
                        if (UserPreferences.LightRails)
                        {
                            inUse = light_rails;
                        }
                        else
                        {
                            inUse = null;
                            continue;
                        }
                    }
                    else
                    {
                        inUse = null;
                        continue;
                    }
                    
                }
            }
            else
            {
                inUse = null;
                continue;
            }
                                             
            GameObject go = new GameObject();
            var waytext = go.AddComponent<Text>();
            foreach (string tramline in w.Value.TransportLines)
            {
                waytext.text += tramline + ", ";
            }
            Vector3 localOrigin = GetCentre(w.Value);
            go.transform.position = localOrigin - MapReader.bounds.Centre;

            MeshFilter mf = go.AddComponent<MeshFilter>();
            MeshRenderer mr = go.AddComponent<MeshRenderer>();

            mr.material = inUse;

            // Here we store the vectors, normales and indexes.
            List<Vector3> vectors = new List<Vector3>();  
            List<Vector3> normals = new List<Vector3>();
            List<int> indicies = new List<int>();

            for (int i = 1; i < w.Value.NodeIDs.Count; i++)
            {
                OsmNode p1 = MapReader.nodes[w.Value.NodeIDs[i - 1]];
                OsmNode p2 = MapReader.nodes[w.Value.NodeIDs[i]];

                Vector3 s1 = p1 - localOrigin;  
                Vector3 s2 = p2 - localOrigin;

                Vector3 diff = (s2 - s1).normalized;

                // The width of road and railroads is set to 1 meter.
                var cross = Vector3.Cross(diff, Vector3.up) * 1.0f; 

                Vector3 v1 = s1 + cross;
                Vector3 v2 = s1 - cross;
                Vector3 v3 = s2 + cross;
                Vector3 v4 = s2 - cross;

                vectors.Add(v1);  
                vectors.Add(v2);
                vectors.Add(v3);
                vectors.Add(v4);

                normals.Add(Vector3.up);  
                normals.Add(Vector3.up);
                normals.Add(Vector3.up);
                normals.Add(Vector3.up);

                int idx1, idx2, idx3, idx4;
                idx4 = vectors.Count - 1;
                idx3 = vectors.Count - 2;
                idx2 = vectors.Count - 3;
                idx1 = vectors.Count - 4;

                indicies.Add(idx1);
                indicies.Add(idx3);
                indicies.Add(idx2);

                indicies.Add(idx3);
                indicies.Add(idx4);
                indicies.Add(idx2);
            }
            go.name += w.Value.ID;
            mf.mesh.vertices = vectors.ToArray();
            mf.mesh.normals = normals.ToArray();
            mf.mesh.triangles = indicies.ToArray();

            yield return null;

            // Lastly we store the Unity coordinates of every generated way. This is then used later on
            // when we want to move the transport vehicles across the ways.
            for(int i = 0; i < w.Value.NodeIDs.Count; i++)
            {
                OsmNode p1 = MapReader.nodes[w.Value.NodeIDs[i]];
                w.Value.UnityCoordinates.Add(p1 - MapReader.bounds.Centre);
            }
        }
    }

19 View Source File : ProximityEffect.cs
License : Apache License 2.0
Project Creator : abist-co-ltd

public void UpdateScaling(Vector3 boundsCenter, Vector3 boundsExtents)
        {
            // early out if effect is disabled
            if (config.ProximityEffectActive == false || !IsAnyRegisteredObjectVisible())
            {
                return;
            }

            proximityPointers.Clear();
            proximityPoints.Clear();

            // Find all valid pointers
            foreach (var inputSource in CoreServices.InputSystem.DetectedInputSources)
            {
                foreach (var pointer in inputSource.Pointers)
                {
                    // don't use IsInteractionEnabled for near pointers as the pointers might have a different radius when deciding
                    // if they can interact with a near-by object - we might still want to show proximity scaling even if
                    // eg. grab pointer decides it's too far away to actually perform the interaction
                    if (pointer.IsActive && !proximityPointers.Contains(pointer))
                    {
                        proximityPointers.Add(pointer);
                    }
                }
            }

            // Get the max radius possible of our current bounds and extent the range to include proximity scaled objects. This is done by adjusting the original bounds to include the ObjectMediumProximity range in x, y and z axis
            float squareMaxLength = boundsExtents.sqrMagnitude + (3 * config.ObjectMediumProximity * config.ObjectMediumProximity);

            // Grab points within sphere of influence from valid pointers
            foreach (var pointer in proximityPointers)
            {
                if (IsPointWithinBounds(boundsCenter, pointer.Position, squareMaxLength))
                {
                    proximityPoints.Add(pointer.Position);
                }
                
                if (pointer.Result?.CurrentPointerTarget != null)
                { 
                    Vector3? point = pointer.Result?.Details.Point;
                    if (point.HasValue && IsPointWithinBounds(boundsCenter, pointer.Result.Details.Point, squareMaxLength))
                    {
                        proximityPoints.Add(pointer.Result.Details.Point);
                    }
                }
            }

            // Loop through all objects and find closest one
            Transform closestObject = null;
            float closestDistanceSqr = float.MaxValue;
            foreach (var point in proximityPoints)
            {

                foreach (var keyValuePair in registeredObjects)
                {

                    foreach (var item in keyValuePair.Value)
                    {
                        // If object can't be visible, skip calculations
                        if (!keyValuePair.Key.IsActive)
                        {
                            continue;
                        }

                        // Perform comparison on sqr distance since sqrt() operation is expensive in Vector3.Distance()
                        float sqrDistance = (item.ScaledObject.transform.position - point).sqrMagnitude;
                        if (sqrDistance < closestDistanceSqr)
                        {
                            closestObject = item.ScaledObject;
                            closestDistanceSqr = sqrDistance;
                        }
                    }
                }
            }

            // Loop through all objects and update visual state based on closest point
            foreach (var keyValuePair in registeredObjects)
            {
                foreach (var item in keyValuePair.Value)
                {
                    ProximityState newState = (closestObject == item.ScaledObject) ? GetProximityState(closestDistanceSqr) : ProximityState.FullsizeNoProximity;
                    IProximityEffectObjectProvider provider = keyValuePair.Key;

                    // Only apply updates if object is in a new state or closest object needs to lerp scaling
                    if (item.ProximityState != newState)
                    {
                        // Update and save new state
                        item.ProximityState = newState;

                        if (item.ObjectVisualRenderer)
                        {
                            item.ObjectVisualRenderer.material = newState == ProximityState.CloseProximity ? provider.GetHighlightedMaterial() : provider.GetBaseMaterial();
                        }
                    }

                    ScaleObject(newState, item.ScaledObject, provider.GetObjectSize(), true);
                }
            }
        }

19 View Source File : SortWay.cs
License : MIT License
Project Creator : alen-smajic

private void Start()
    {
        allWayCoordinates = new List<List<Vector3>>();
        SortedPathAndWays = new List<List<List<Vector3>>>();
        SplittedinPaths = new List<List<Vector3>>();
        PathsInRightOrder = new List<List<Vector3>>();

        MoveToTarget = new List<Vector3>();
        PathLastNode = new List<Vector3>();

        List<GameObject> allObjects = new List<GameObject>();
        Scene scene = SceneManager.GetActiveScene();
        scene.GetRootGameObjects(allObjects);

        // This for loop returns a list "allWayCoordinates" which contains more lists. Every list of these are way objects
        // which contain the node coordinates
        for (int i = 0; i < TranSportWayMarker.SelectedWays.Count; i++)
        {
            string ObjectName = allObjects[TranSportWayMarker.SelectedWays[i]].name;
            string ObjectID = ObjectName.Substring(15); // The ID of the way is being determined in order to search for it in the MapReader clreplaced.

            List<Vector3> WayNodes = new List<Vector3>();
            for (int j = 0; j < MapReader.ways[Convert.ToUInt64(ObjectID)].UnityCoordinates.Count; j++)
            {
                WayNodes.Add(MapReader.ways[Convert.ToUInt64(ObjectID)].UnityCoordinates[j]);
            }
            allWayCoordinates.Add(WayNodes); 
            // allWayCoordinates contains lists which represent the way objects. Every single one of these lists contains the node coordinates as values.
        }

        // Next we create a new list (SortedPathAndWays). This list merges the ways that belong to a common path.
        // E.g. if a bus line ends on one edge of the map and continues at another edge of the map, the corresponding ways will be stored in different lists.
        List<List<Vector3>> localList = new List<List<Vector3>>();
        localList.Add(allWayCoordinates[0]);
        SortedPathAndWays.Add(localList);
        allWayCoordinates.RemoveAt(0);

        // Is being called to sort the SortedPathAndWays with  respect to allWayCoordinates.
        SortList(allWayCoordinates, 0);

        // Here we transform the three-dimensional SortedPathAndWays list into a two-dimensional list. We do this by concatenating the inner lists
        // because these are already sorted.
        List<Vector3> temporaryList = new List<Vector3>();
        for(int i = 0; i < SortedPathAndWays.Count; i++) 
        {
            temporaryList = SortedPathAndWays[i].SelectMany(x => x).ToList();
            SplittedinPaths.Add(temporaryList);
        }

        for(int i = 0; i < TranSportWayMarker.StationOrder.Count; i++)
        {
            for(int j = 0; j < SplittedinPaths.Count; j++)
            {
                for(int k = 0; k < SplittedinPaths[j].Count; k++)
                {
                    if(TranSportWayMarker.StationOrder[i] == SplittedinPaths[j][k])
                    {
                        if (PathsInRightOrder.Contains(SplittedinPaths[j]))
                        {
                            break;
                        }
                        else
                        {
                            PathsInRightOrder.Add(SplittedinPaths[j]);
                        }
                    }
                }
            }
        }

        // Append paths which dont contain any station at the end.
        for(int i = 0; i < SplittedinPaths.Count; i++)
        {
            if (!PathsInRightOrder.Contains(SplittedinPaths[i]))
            {
                PathsInRightOrder.Add(SplittedinPaths[i]);
            }
        }

        // Switch the direction of the values within the paths using the stations.
        int firstIndex = -1;
        int secondIndex = -1;
        for(int i = 0; i < TranSportWayMarker.StationOrder.Count; i++)
        {
            for(int k = 0; k < PathsInRightOrder.Count; k++)
            {
                for(int j = 0; j < PathsInRightOrder[k].Count; j++)
                {
                    if(TranSportWayMarker.StationOrder[i] == PathsInRightOrder[k][j])
                    {
                        if(firstIndex == -1)
                        {
                            firstIndex = j;
                            break;
                        }
                        else
                        {
                            secondIndex = j;
                            break;
                        }
                    }
                }
                if(firstIndex != -1 && secondIndex != -1)
                {
                    if(firstIndex > secondIndex)
                    {
                        PathsInRightOrder[k].Reverse();
                        break;
                    }
                }
            }
        }

        for(int i = 0; i < PathsInRightOrder.Count; i++)
        {
            for(int j = 0; j < SortWay.PathsInRightOrder[i].Count; j++)
            {
                MoveToTarget.Add(SortWay.PathsInRightOrder[i][j]);
            }
        }

        if(SortWay.PathsInRightOrder.Count > 1)
        {
            for(int i = 0; i < PathsInRightOrder.Count; i++)
            {
                PathLastNode.Add(PathsInRightOrder[i][PathsInRightOrder[i].Count - 1]);
            }
        }

        IdentifyVehicle();
    }

19 View Source File : TeleportAimHandlerLaser.cs
License : MIT License
Project Creator : absurd-joy

public override void GetPoints(List<Vector3> points)
	{
		Ray aimRay;
		LocomotionTeleport.InputHandler.GetAimData(out aimRay);
		points.Add(aimRay.origin);
		points.Add(aimRay.origin + aimRay.direction * Range);
	}

19 View Source File : MeshUtility.cs
License : Apache License 2.0
Project Creator : aivclab

public static Mesh CreateIcoSphere(int recursion_level, float radius) {
      var mesh = new Mesh();

      var vert_list = new List<Vector3>();
      var middle_point_index_cache = new Dictionary<long, int>();

      // create 12 vertices of a icosahedron
      var t = (1f + Mathf.Sqrt(5f)) / 2f;

      vert_list.Add(item : new Vector3(-1f, y : t, 0f).normalized * radius);
      vert_list.Add(item : new Vector3(1f, y : t, 0f).normalized * radius);
      vert_list.Add(item : new Vector3(-1f, y : -t, 0f).normalized * radius);
      vert_list.Add(item : new Vector3(1f, y : -t, 0f).normalized * radius);

      vert_list.Add(item : new Vector3(0f, -1f, z : t).normalized * radius);
      vert_list.Add(item : new Vector3(0f, 1f, z : t).normalized * radius);
      vert_list.Add(item : new Vector3(0f, -1f, z : -t).normalized * radius);
      vert_list.Add(item : new Vector3(0f, 1f, z : -t).normalized * radius);

      vert_list.Add(item : new Vector3(x : t, 0f, -1f).normalized * radius);
      vert_list.Add(item : new Vector3(x : t, 0f, 1f).normalized * radius);
      vert_list.Add(item : new Vector3(x : -t, 0f, -1f).normalized * radius);
      vert_list.Add(item : new Vector3(x : -t, 0f, 1f).normalized * radius);

      // create 20 triangles of the icosahedron
      var faces = new List<TriangleIndices> {
                                                // 5 faces around point 0
                                                new TriangleIndices(0, 11, 5),
                                                new TriangleIndices(0, 5, 1),
                                                new TriangleIndices(0, 1, 7),
                                                new TriangleIndices(0, 7, 10),
                                                new TriangleIndices(0, 10, 11),
                                                // 5 adjacent faces
                                                new TriangleIndices(1, 5, 9),
                                                new TriangleIndices(5, 11, 4),
                                                new TriangleIndices(11, 10, 2),
                                                new TriangleIndices(10, 7, 6),
                                                new TriangleIndices(7, 1, 8),
                                                // 5 faces around point 3
                                                new TriangleIndices(3, 9, 4),
                                                new TriangleIndices(3, 4, 2),
                                                new TriangleIndices(3, 2, 6),
                                                new TriangleIndices(3, 6, 8),
                                                new TriangleIndices(3, 8, 9),
                                                // 5 adjacent faces
                                                new TriangleIndices(4, 9, 5),
                                                new TriangleIndices(2, 4, 11),
                                                new TriangleIndices(6, 2, 10),
                                                new TriangleIndices(8, 6, 7),
                                                new TriangleIndices(9, 8, 1)
                                            };

      // refine triangles
      for (var i = 0; i < recursion_level; i++) {
        var faces2 = new List<TriangleIndices>();
        for (var index = 0; index < faces.Count; index++) {
          var tri = faces[index : index];
// replace triangle by 4 triangles
          var a = GetMiddlePoint(p1 : tri._V1,
                                 p2 : tri._V2,
                                 vertices : ref vert_list,
                                 cache : ref middle_point_index_cache,
                                 radius : radius);
          var b = GetMiddlePoint(p1 : tri._V2,
                                 p2 : tri._V3,
                                 vertices : ref vert_list,
                                 cache : ref middle_point_index_cache,
                                 radius : radius);
          var c = GetMiddlePoint(p1 : tri._V3,
                                 p2 : tri._V1,
                                 vertices : ref vert_list,
                                 cache : ref middle_point_index_cache,
                                 radius : radius);

          faces2.Add(item : new TriangleIndices(v1 : tri._V1, v2 : a, v3 : c));
          faces2.Add(item : new TriangleIndices(v1 : tri._V2, v2 : b, v3 : a));
          faces2.Add(item : new TriangleIndices(v1 : tri._V3, v2 : c, v3 : b));
          faces2.Add(item : new TriangleIndices(v1 : a, v2 : b, v3 : c));
        }

        faces = faces2;
      }

      mesh.vertices = vert_list.ToArray();

      var tri_list = new List<int>();
      for (var i = 0; i < faces.Count; i++) {
        tri_list.Add(item : faces[index : i]._V1);
        tri_list.Add(item : faces[index : i]._V2);
        tri_list.Add(item : faces[index : i]._V3);
      }

      mesh.triangles = tri_list.ToArray();
      mesh.uv = new Vector2[vert_list.Count];

      var normals = new Vector3[vert_list.Count];
      for (var i = 0; i < normals.Length; i++) {
        normals[i] = vert_list[index : i].normalized;
      }

      mesh.normals = normals;

      mesh.RecalculateBounds();

      return mesh;
    }

19 View Source File : RoadGenerator.cs
License : Apache License 2.0
Project Creator : Aggrathon

public void Generate(float[,] heights, Vector3 terrainSize, Vector3 terrainPosition, float waterRelativeHeight)
	{
		int heightWidth = heights.GetLength(0);
		System.Random rnd = new System.Random();
		int pathFindingGraphSize = heightWidth / pathFindingSpacing - 2 * pathFindingGraphMargin;

		Pathfinding.PathFindNode[,] nodes = new Pathfinding.PathFindNode[pathFindingGraphSize, pathFindingGraphSize];
		for (int i = 1; i < pathFindingGraphSize - 1; i++)
		{
			for (int j = 1; j < pathFindingGraphSize - 1; j++)
			{
				float nodeHeight = heights[(i + pathFindingGraphMargin) * pathFindingSpacing, (j + pathFindingGraphMargin) * pathFindingSpacing];
				if (nodeHeight > waterRelativeHeight + 0.03f)
					nodes[i, j] = new Pathfinding.PathFindNode(i, j, nodeHeight);
			}
		}
		Pathfinding pf = new Pathfinding(nodes, heightPenalty);
		List<Pathfinding.PathFindNode> path = pf.GetRoad(numCheckpoints, rnd);
		road.Clear();
		for (int i = 0; i < path.Count; i++)
		{
			Vector3 pos = Vector3.Scale(terrainSize, path[i].GetLocalPosition(pathFindingGraphSize, pathFindingGraphSize, pathFindingGraphMargin)) + terrainPosition;
			if (road.Count < 1 || Vector3.SqrMagnitude(pos - road[road.Count - 1]) > 1)
				road.Add(pos);
		}
	}

19 View Source File : OVROverlayMeshGenerator.cs
License : MIT License
Project Creator : absurd-joy

public static void BuildQuad(List<Vector3> verts, List<Vector2> uv, List<int> triangles, Rect rect)
    {        
        verts.Add(new Vector3(rect.x - 0.5f, (1 - rect.y - rect.height) - 0.5f, 0));
        verts.Add(new Vector3(rect.x - 0.5f, (1 - rect.y) - 0.5f, 0));
        verts.Add(new Vector3(rect.x + rect.width - 0.5f, (1 - rect.y) - 0.5f, 0));
        verts.Add(new Vector3(rect.x + rect.width - 0.5f, (1 - rect.y - rect.height) - 0.5f, 0));

        uv.Add(new Vector2(0, 0));
        uv.Add(new Vector2(0, 1));
        uv.Add(new Vector2(1, 1));
        uv.Add(new Vector2(1, 0));

        triangles.Add(0);
        triangles.Add(1);
        triangles.Add(2);
        triangles.Add(2);
        triangles.Add(3);
        triangles.Add(0);
    }

19 View Source File : MeshUtility.cs
License : Apache License 2.0
Project Creator : aivclab

public static Mesh GenerateSpotlightCircleMesh2( Camera main, float radius = 1f, int n = 60) {
      if (!main) {
        return null;
      }
      var mesh = new Mesh();

      var vertices_list = new List<Vector3> { };
      float x;
      float y;
      for (var i = 0; i < n; i++) {
        x = radius * Mathf.Sin(f : (2 * Mathf.PI * i) / n);
        y = radius * Mathf.Cos(f : (2 * Mathf.PI * i) / n);
        vertices_list.Add(item : new Vector3(x : x, y : y, 0f));
      }

      var vertices = vertices_list.ToArray();

      //triangles
      var triangles_list = new List<int> { };
      for (var i = 0; i < (n - 2); i++) {
        triangles_list.Add(0);
        triangles_list.Add(item : i + 1);
        triangles_list.Add(item : i + 2);
      }

      var triangles = triangles_list.ToArray();

      var x1 = Mathf.Tan(f : main.fieldOfView * 0.5f * Mathf.Deg2Rad) * main.aspect * main.nearClipPlane;
      var y1 = Mathf.Tan(f : main.fieldOfView * 0.5f * Mathf.Deg2Rad) * main.nearClipPlane;
      var z1 = main.nearClipPlane;

      //normals
      var normals_list = new List<Vector3> { };
      for (var i = 0; i < vertices.Length; i++) {
        normals_list.Add(item : Vector3.forward);
      }

      var normals = normals_list.ToArray();

      //initialise
      mesh.vertices = vertices;
      mesh.triangles = triangles;
      mesh.normals = normals;

      return mesh;
    }

19 View Source File : BaseBoundarySystem.cs
License : Apache License 2.0
Project Creator : abist-co-ltd

public GameObject GetTrackedAreaVisualization()
        {
            if (!Application.isPlaying) { return null; }

            if (currentTrackedAreaObject != null)
            {
                return currentTrackedAreaObject;
            }

            MixedRealityBoundaryVisualizationProfile profile = ConfigurationProfile as MixedRealityBoundaryVisualizationProfile;
            if (profile == null) { return null; }

            if (Bounds.Length == 0)
            {
                // If we do not have boundary edges, we cannot render them.
                return null;
            }

            // Get the line vertices
            List<Vector3> lineVertices = new List<Vector3>();
            for (int i = 0; i < Bounds.Length; i++)
            {
                lineVertices.Add(new Vector3(Bounds[i].PointA.x, 0f, Bounds[i].PointA.y));
            }
            // Add the first vertex again to ensure the loop closes.
            lineVertices.Add(lineVertices[0]);

            // We use an empty object and attach a line renderer.
            currentTrackedAreaObject = new GameObject("Tracked Area")
            {
                layer = ignoreRaycastLayerValue
            };
            currentTrackedAreaObject.AddComponent<LineRenderer>();
            currentTrackedAreaObject.transform.Translate(new Vector3(
                MixedRealityPlayspace.Position.x,
                boundaryObjectRenderOffset,
                MixedRealityPlayspace.Position.z));
            currentPlayAreaObject.layer = TrackedAreaPhysicsLayer;

            // Configure the renderer properties.
            float lineWidth = 0.01f;
            LineRenderer lineRenderer = currentTrackedAreaObject.GetComponent<LineRenderer>();
            lineRenderer.sharedMaterial = profile.TrackedAreaMaterial;
            lineRenderer.useWorldSpace = false;
            lineRenderer.startWidth = lineWidth;
            lineRenderer.endWidth = lineWidth;
            lineRenderer.positionCount = lineVertices.Count;
            lineRenderer.SetPositions(lineVertices.ToArray());

            currentTrackedAreaObject.transform.parent = BoundaryVisualizationParent.transform;

            return currentTrackedAreaObject;
        }

19 View Source File : LowPolyTerrainStrategy.cs
License : MIT License
Project Creator : alen-smajic

private void CreateBaseMesh(UnityTile tile)
		{
			//TODO use arrays instead of lists
			_newVertexList.Clear();
			_newNormalList.Clear();
			_newUvList.Clear();
			_newTriangleList.Clear();

			var cap = (_elevationOptions.modificationOptions.sampleCount - 1);
			for (float y = 0; y < cap; y++)
			{
				for (float x = 0; x < cap; x++)
				{
					var x1 = tile.TileScale * (float)(Mathd.Lerp(tile.Rect.Min.x, tile.Rect.Max.x, x / cap) - tile.Rect.Center.x);
					var y1 = tile.TileScale * (float)(Mathd.Lerp(tile.Rect.Min.y, tile.Rect.Max.y, y / cap) - tile.Rect.Center.y);
					var x2 = tile.TileScale * (float)(Mathd.Lerp(tile.Rect.Min.x, tile.Rect.Max.x, (x + 1) / cap) - tile.Rect.Center.x);
					var y2 = tile.TileScale * (float)(Mathd.Lerp(tile.Rect.Min.y, tile.Rect.Max.y, (y + 1) / cap) - tile.Rect.Center.y);

					var triStart = _newVertexList.Count;
					_newVertexList.Add(new Vector3(x1, 0, y1));
					_newVertexList.Add(new Vector3(x2, 0, y1));
					_newVertexList.Add(new Vector3(x1, 0, y2));
					//--
					_newVertexList.Add(new Vector3(x2, 0, y1));
					_newVertexList.Add(new Vector3(x2, 0, y2));
					_newVertexList.Add(new Vector3(x1, 0, y2));

					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);
					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);
					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);
					//--
					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);
					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);
					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);


					_newUvList.Add(new Vector2(x / cap, 1 - y / cap));
					_newUvList.Add(new Vector2((x + 1) / cap, 1 - y / cap));
					_newUvList.Add(new Vector2(x / cap, 1 - (y + 1) / cap));
					//--
					_newUvList.Add(new Vector2((x + 1) / cap, 1 - y / cap));
					_newUvList.Add(new Vector2((x + 1) / cap, 1 - (y + 1) / cap));
					_newUvList.Add(new Vector2(x / cap, 1 - (y + 1) / cap));

					_newTriangleList.Add(triStart);
					_newTriangleList.Add(triStart + 1);
					_newTriangleList.Add(triStart + 2);
					//--
					_newTriangleList.Add(triStart + 3);
					_newTriangleList.Add(triStart + 4);
					_newTriangleList.Add(triStart + 5);
				}
			}


			var mesh = tile.MeshFilter.sharedMesh;
			mesh.indexFormat = IndexFormat.UInt32;
			mesh.SetVertices(_newVertexList);
			mesh.SetNormals(_newNormalList);
			mesh.SetUVs(0, _newUvList);
			mesh.SetTriangles(_newTriangleList, 0);
			mesh.RecalculateBounds();
		}

19 View Source File : SetupModel.cs
License : GNU Affero General Public License v3.0
Project Creator : ACEmulator

public override void Unpack(BinaryReader reader)
        {
            Id = reader.ReadUInt32();

            Flags = (SetupFlags)reader.ReadUInt32();

            AllowFreeHeading    = (Flags & SetupFlags.AllowFreeHeading) != 0;
            HasPhysicsBSP       = (Flags & SetupFlags.HasPhysicsBSP) != 0;

            // Get all the GraphicsObjects in this SetupModel. These are all the 01-types.
            uint numParts = reader.ReadUInt32();
            for (int i = 0; i < numParts; i++)
                Parts.Add(reader.ReadUInt32());

            if ((Flags & SetupFlags.HasParent) != 0)
            {
                for (int i = 0; i < numParts; i++)
                    ParentIndex.Add(reader.ReadUInt32());
            }

            if ((Flags & SetupFlags.HasDefaultScale) != 0)
            {
                for (int i = 0; i < numParts; i++)
                    DefaultScale.Add(reader.ReadVector3());
            }

            HoldingLocations.Unpack(reader);
            ConnectionPoints.Unpack(reader);

            int placementsCount = reader.ReadInt32();
            for (int i = 0; i < placementsCount; i++)
            {
                int key = reader.ReadInt32();
                // there is a frame for each Part
                var placementType = new PlacementType();
                placementType.Unpack(reader, (uint)Parts.Count);
                PlacementFrames.Add(key, placementType);
            }

            CylSpheres.Unpack(reader);

            Spheres.Unpack(reader);

            Height          = reader.ReadSingle();
            Radius          = reader.ReadSingle();
            StepUpHeight    = reader.ReadSingle();
            StepDownHeight  = reader.ReadSingle();

            SortingSphere.Unpack(reader);
            SelectionSphere.Unpack(reader);

            Lights.Unpack(reader);

            DefaultAnimation    = reader.ReadUInt32();
            DefaultScript       = reader.ReadUInt32();
            DefaultMotionTable  = reader.ReadUInt32();
            DefaultSoundTable   = reader.ReadUInt32();
            DefaultScriptTable  = reader.ReadUInt32();
        }

19 View Source File : ElevatedTerrainWithSidesStrategy.cs
License : MIT License
Project Creator : alen-smajic

private void CreateBaseMesh(UnityTile tile)
		{
			//TODO use arrays instead of lists
			_newVertexList.Clear();
			_newNormalList.Clear();
			_newUvList.Clear();
			_newTriangleList.Clear();

			var _sampleCount = _elevationOptions.modificationOptions.sampleCount;
			for (float y = 0; y < _sampleCount; y++)
			{
				var yrat = y / (_sampleCount - 1);
				for (float x = 0; x < _sampleCount; x++)
				{
					var xrat = x / (_sampleCount - 1);

					var xx = Mathd.Lerp(tile.Rect.Min.x, tile.Rect.Max.x, xrat);
					var yy = Mathd.Lerp(tile.Rect.Min.y, tile.Rect.Max.y, yrat);

					_newVertexList.Add(new Vector3(
						(float)(xx - tile.Rect.Center.x) * tile.TileScale,
						0,
						(float)(yy - tile.Rect.Center.y) * tile.TileScale));
					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);
					_newUvList.Add(new Vector2(x * 1f / (_sampleCount - 1), 1 - (y * 1f / (_sampleCount - 1))));
				}
			}

			int vertA, vertB, vertC;
			for (int y = 0; y < _sampleCount - 1; y++)
			{
				for (int x = 0; x < _sampleCount - 1; x++)
				{
					vertA = (y * _sampleCount) + x;
					vertB = (y * _sampleCount) + x + _sampleCount + 1;
					vertC = (y * _sampleCount) + x + _sampleCount;
					_newTriangleList.Add(vertA);
					_newTriangleList.Add(vertB);
					_newTriangleList.Add(vertC);

					vertA = (y * _sampleCount) + x;
					vertB = (y * _sampleCount) + x + 1;
					vertC = (y * _sampleCount) + x + _sampleCount + 1;
					_newTriangleList.Add(vertA);
					_newTriangleList.Add(vertB);
					_newTriangleList.Add(vertC);
				}
			}

			var sideVertBase = _newVertexList.Count;

			var lastRow = (_sampleCount - 1) * _sampleCount;
			var baseTriList = new List<int>();
			for (int x = 0; x < _sampleCount; x++)
			{
				//side wall
				//024
				//135
				_newVertexList.Add(_newVertexList[x]);
				_newVertexList.Add(new Vector3(
					_newVertexList[x].x,
					-_elevationOptions.sideWallOptions.wallHeight,
					_newVertexList[x].z));
				_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Forward);
				_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Forward);
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 1));
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 0));

				//---

				_newVertexList.Add(_newVertexList[x * _sampleCount]);
				_newVertexList.Add(new Vector3(
						_newVertexList[x * _sampleCount].x,
					-_elevationOptions.sideWallOptions.wallHeight,
						_newVertexList[x * _sampleCount].z));
				_newNormalList.Add(Vector3.left);
				_newNormalList.Add(Vector3.left);
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 1));
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 0));

				//---

				_newVertexList.Add(_newVertexList[(x + 1) * _sampleCount - 1]);
				_newVertexList.Add(new Vector3(
						_newVertexList[(x + 1) * _sampleCount - 1].x,
					-_elevationOptions.sideWallOptions.wallHeight,
						_newVertexList[(x + 1) * _sampleCount - 1].z));
				_newNormalList.Add(Vector3.right);
				_newNormalList.Add(Vector3.right);
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 1));
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 0));

				//---

				_newVertexList.Add(_newVertexList[lastRow + x]);
				_newVertexList.Add(new Vector3(
					_newVertexList[lastRow + x].x,
					-_elevationOptions.sideWallOptions.wallHeight,
					_newVertexList[lastRow + x].z));
				_newNormalList.Add(Vector3.back);
				_newNormalList.Add(Vector3.back);
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 1));
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 0));

				if (x > 0)
				{
					baseTriList.Add(sideVertBase + 8 * x);
					baseTriList.Add(sideVertBase + 8 * x - 8);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1);

					baseTriList.Add(sideVertBase + 8 * x);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1);
					baseTriList.Add(sideVertBase + 8 * x + 1);

					//---

					baseTriList.Add(sideVertBase + 8 * x + 2);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1 + 2);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 2);

					baseTriList.Add(sideVertBase + 8 * x + 2);
					baseTriList.Add(sideVertBase + 8 * x + 1 + 2);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1 + 2);

					//---

					baseTriList.Add(sideVertBase + 8 * x + 4);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 4);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1 + 4);

					baseTriList.Add(sideVertBase + 8 * x + 4);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1 + 4);
					baseTriList.Add(sideVertBase + 8 * x + 1 + 4);

					//---

					baseTriList.Add(sideVertBase + 8 * x + 6);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1 + 6);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 6);

					baseTriList.Add(sideVertBase + 8 * x + 6);
					baseTriList.Add(sideVertBase + 8 * x + 1 + 6);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1 + 6);
				}
			}


			var mesh = tile.MeshFilter.mesh;
			mesh.SetVertices(_newVertexList);
			mesh.SetNormals(_newNormalList);
			mesh.SetUVs(0, _newUvList);
			mesh.subMeshCount = 2;
			mesh.SetTriangles(_newTriangleList, 0);
			mesh.SetTriangles(baseTriList, 1);
		}

19 View Source File : RiggedHand.cs
License : MIT License
Project Creator : 39M

[ContextMenu("StoreJointsStartPose")]
    public void StoreJointsStartPose() {
      foreach (Transform t in palm.parent.GetComponentsInChildren<Transform>()) {
        jointList.Add(t);
        localRotations.Add(t.localRotation);
        localPositions.Add(t.localPosition);
      }
    }

19 View Source File : SortWay.cs
License : MIT License
Project Creator : alen-smajic

private void Start()
    {
        allWayCoordinates = new List<List<Vector3>>();
        SortedPathAndWays = new List<List<List<Vector3>>>();
        SplittedinPaths = new List<List<Vector3>>();
        PathsInRightOrder = new List<List<Vector3>>();

        MoveToTarget = new List<Vector3>();
        PathLastNode = new List<Vector3>();

        List<GameObject> allObjects = new List<GameObject>();
        Scene scene = SceneManager.GetActiveScene();
        scene.GetRootGameObjects(allObjects);

        // This for loop returns a list "allWayCoordinates" which contains more lists. Every list of these are way objects
        // which contain the node coordinates
        for (int i = 0; i < TranSportWayMarker.SelectedWays.Count; i++)
        {
            string ObjectName = allObjects[TranSportWayMarker.SelectedWays[i]].name;
            string ObjectID = ObjectName.Substring(15); // The ID of the way is being determined in order to search for it in the MapReader clreplaced.

            List<Vector3> WayNodes = new List<Vector3>();
            for (int j = 0; j < MapReader.ways[Convert.ToUInt64(ObjectID)].UnityCoordinates.Count; j++)
            {
                WayNodes.Add(MapReader.ways[Convert.ToUInt64(ObjectID)].UnityCoordinates[j]);
            }
            allWayCoordinates.Add(WayNodes); 
            // allWayCoordinates contains lists which represent the way objects. Every single one of these lists contains the node coordinates as values.
        }

        // Next we create a new list (SortedPathAndWays). This list merges the ways that belong to a common path.
        // E.g. if a bus line ends on one edge of the map and continues at another edge of the map, the corresponding ways will be stored in different lists.
        List<List<Vector3>> localList = new List<List<Vector3>>();
        localList.Add(allWayCoordinates[0]);
        SortedPathAndWays.Add(localList);
        allWayCoordinates.RemoveAt(0);

        // Is being called to sort the SortedPathAndWays with  respect to allWayCoordinates.
        SortList(allWayCoordinates, 0);

        // Here we transform the three-dimensional SortedPathAndWays list into a two-dimensional list. We do this by concatenating the inner lists
        // because these are already sorted.
        List<Vector3> temporaryList = new List<Vector3>();
        for(int i = 0; i < SortedPathAndWays.Count; i++) 
        {
            temporaryList = SortedPathAndWays[i].SelectMany(x => x).ToList();
            SplittedinPaths.Add(temporaryList);
        }

        for(int i = 0; i < TranSportWayMarker.StationOrder.Count; i++)
        {
            for(int j = 0; j < SplittedinPaths.Count; j++)
            {
                for(int k = 0; k < SplittedinPaths[j].Count; k++)
                {
                    if(TranSportWayMarker.StationOrder[i] == SplittedinPaths[j][k])
                    {
                        if (PathsInRightOrder.Contains(SplittedinPaths[j]))
                        {
                            break;
                        }
                        else
                        {
                            PathsInRightOrder.Add(SplittedinPaths[j]);
                        }
                    }
                }
            }
        }

        // Append paths which dont contain any station at the end.
        for(int i = 0; i < SplittedinPaths.Count; i++)
        {
            if (!PathsInRightOrder.Contains(SplittedinPaths[i]))
            {
                PathsInRightOrder.Add(SplittedinPaths[i]);
            }
        }

        // Switch the direction of the values within the paths using the stations.
        int firstIndex = -1;
        int secondIndex = -1;
        for(int i = 0; i < TranSportWayMarker.StationOrder.Count; i++)
        {
            for(int k = 0; k < PathsInRightOrder.Count; k++)
            {
                for(int j = 0; j < PathsInRightOrder[k].Count; j++)
                {
                    if(TranSportWayMarker.StationOrder[i] == PathsInRightOrder[k][j])
                    {
                        if(firstIndex == -1)
                        {
                            firstIndex = j;
                            break;
                        }
                        else
                        {
                            secondIndex = j;
                            break;
                        }
                    }
                }
                if(firstIndex != -1 && secondIndex != -1)
                {
                    if(firstIndex > secondIndex)
                    {
                        PathsInRightOrder[k].Reverse();
                        break;
                    }
                }
            }
        }

        for(int i = 0; i < PathsInRightOrder.Count; i++)
        {
            for(int j = 0; j < SortWay.PathsInRightOrder[i].Count; j++)
            {
                MoveToTarget.Add(SortWay.PathsInRightOrder[i][j]);
            }
        }

        if(SortWay.PathsInRightOrder.Count > 1)
        {
            for(int i = 0; i < PathsInRightOrder.Count; i++)
            {
                PathLastNode.Add(PathsInRightOrder[i][PathsInRightOrder[i].Count - 1]);
            }
        }

        IdentifyVehicle();
    }

19 View Source File : BuiltinDebugViewsComponent.cs
License : MIT License
Project Creator : AdultLink

public void BuildMesh(int columns, int rows)
            {
                // Base shape
                var arrow = new Vector3[6]
                {
                    new Vector3(0f, 0f, 0f),
                    new Vector3(0f, 1f, 0f),
                    new Vector3(0f, 1f, 0f),
                    new Vector3(-1f, 1f, 0f),
                    new Vector3(0f, 1f, 0f),
                    new Vector3(1f, 1f, 0f)
                };

                // make the vertex array
                int vcount = 6 * columns * rows;
                var vertices = new List<Vector3>(vcount);
                var uvs = new List<Vector2>(vcount);

                for (int iy = 0; iy < rows; iy++)
                {
                    for (int ix = 0; ix < columns; ix++)
                    {
                        var uv = new Vector2(
                                (0.5f + ix) / columns,
                                (0.5f + iy) / rows
                                );

                        for (int i = 0; i < 6; i++)
                        {
                            vertices.Add(arrow[i]);
                            uvs.Add(uv);
                        }
                    }
                }

                // make the index array
                var indices = new int[vcount];

                for (int i = 0; i < vcount; i++)
                    indices[i] = i;

                // initialize the mesh object
                mesh = new Mesh { hideFlags = HideFlags.DontSave };
                mesh.SetVertices(vertices);
                mesh.SetUVs(0, uvs);
                mesh.SetIndices(indices, MeshTopology.Lines, 0);
                mesh.UploadMeshData(true);

                // update the properties
                columnCount = columns;
                rowCount = rows;
            }

19 View Source File : ObjLoader.cs
License : The Unlicense
Project Creator : aeroson

Mesh Parse(Resource resource, GameObject appendToGameObject)
        {
            using (StreamReader textReader = new StreamReader(resource))
            {

                int i1, i2, i3, i4;

                string line;
                while ((line = textReader.ReadLine()) != null)
                {
                    line = line.Trim(trimCharacters);
                    line = line.Replace("  ", " ");

                    string[] parameters = line.Split(splitCharacters);

                    switch (parameters[0])
                    {
                        case "p": // Point
                            break;

                        case "v": // Vertex
                            var v = Vector3.Zero;
                            Parse(ref parameters[1], ref v.X);
                            Parse(ref parameters[2], ref v.Y);
                            Parse(ref parameters[3], ref v.Z);
                            verticesObj.Add(v);
                            break;

                        case "vt": // TexCoord
                            gotUvs = true;
                            var vt = Vector2.Zero;
                            Parse(ref parameters[1], ref vt.X);
                            Parse(ref parameters[2], ref vt.Y);
                            uvsObj.Add(vt);
                            break;

                        case "vn": // Normal
                            gotNormal = true;
                            var vn = Vector3.Zero;
                            Parse(ref parameters[1], ref vn.X);
                            Parse(ref parameters[2], ref vn.Y);
                            Parse(ref parameters[3], ref vn.Z);
                            normalsObj.Add(vn);
                            break;

                        case "f":
                            switch (parameters.Length)
                            {
                                case 4:
                                    i1 = ParseFaceParameter(parameters[1]);
                                    i2 = ParseFaceParameter(parameters[2]);
                                    i3 = ParseFaceParameter(parameters[3]);
                                    triangleIndiciesMesh.Add(i1);
                                    triangleIndiciesMesh.Add(i2);
                                    triangleIndiciesMesh.Add(i3);
                                    break;

                                case 5:
                                    i1 = ParseFaceParameter(parameters[1]);
                                    i2 = ParseFaceParameter(parameters[2]);
                                    i3 = ParseFaceParameter(parameters[3]);
                                    i4 = ParseFaceParameter(parameters[4]);
                                    triangleIndiciesMesh.Add(i1);
                                    triangleIndiciesMesh.Add(i2);
                                    triangleIndiciesMesh.Add(i3);
                                    triangleIndiciesMesh.Add(i1);
                                    triangleIndiciesMesh.Add(i3);
                                    triangleIndiciesMesh.Add(i4);
                                    break;
                            }
                            break;
                        case "mtllib":
                            if (Resource.ResourceInFolderExists(resource, parameters[1]))
                            {
                                materialLibrary = new MaterialLibrary(Resource.GetResourceInFolder(resource, parameters[1]));
                            }
                            break;
                        case "usemtl":
                            if (materialLibrary!=null) lastMaterial = materialLibrary.GetMat(parameters[1]);
                            break;
                    }
                }

                textReader.Close();
            }


            if(appendToGameObject!=null) return EndObjPart(appendToGameObject);

            Debug.Info("Loaded " + resource.originalPath + " vertices:" + verticesMesh.Count + " faces:" + triangleIndiciesMesh.Count / 3);

            return EndMesh();
    
        }

19 View Source File : PlyHandler.cs
License : MIT License
Project Creator : 3DBear

private static PlyResult ParseAscii(List<string> plyFile, PlyHeader header)
        {
            var vertices = new List<Vector3>();
            var triangles = new List<int>();
            var colors = new List<Color>();
            var headerEndIndex = plyFile.IndexOf("end_header");
            var vertexStartIndex = headerEndIndex + 1;
            var faceStartIndex = vertexStartIndex + header.VertexCount + 1;
            plyFile.GetRange(vertexStartIndex, header.VertexCount).ForEach(vertex =>
            {
                var xyzrgb = vertex.Split(' ');
                vertices.Add(ParseVertex(xyzrgb, header));
                colors.Add(ParseColor(xyzrgb, header));
            });

            plyFile.GetRange(faceStartIndex, header.FaceCount).ForEach(face =>
            {
                triangles.AddRange(GetTriangles(face, header));
            });
            return new PlyResult(vertices, triangles, colors);
        }

19 View Source File : LegoPiece.cs
License : The Unlicense
Project Creator : aeroson

public override void Start()
        {

            var m = GetComponent<MeshRenderer>();
            if (m)
            {
                var b=m.mesh.bounds;                

                const float halfSize = 1.139775f;

                int xCount = (int)Math.Round( b.extents.X / halfSize );
                int zCount = (int)Math.Round( b.extents.Z / halfSize );

                for (int x = 0; x < xCount; x++)
                {
                    for (int z = 0; z < zCount; z++)
                    {
                        var slot = b.min + new Vector3(halfSize + x * halfSize * 2, 0, halfSize + z * halfSize * 2);
                        slots.Add(slot);                        

                        var point = slot;
                        point.Y = b.max.Y;
                        point.Y -= 0.45f;
                        points.Add(point);

                        //VisualizePosition.Create(gameObject, point); VisualizePosition.Create(gameObject, slot);
                    }
                }

            }
            
            
        }

19 View Source File : TeleportAimHandlerParabolic.cs
License : MIT License
Project Creator : absurd-joy

public override void GetPoints(List<Vector3> points)
	{
		Ray startRay;

		LocomotionTeleport.InputHandler.GetAimData(out startRay);

		var aimPosition = startRay.origin;
		var aimDirection = startRay.direction * AimVelocity;
		var rangeSquared = Range * Range;
		do
		{
			points.Add(aimPosition);

			var aimVector = aimDirection;
			aimVector.y = aimVector.y + Gravity * 0.0111111111f * AimStep;
			aimDirection = aimVector;
			aimPosition += aimVector * AimStep;

		} while ((aimPosition.y - startRay.origin.y > MinimumElevation) && ((startRay.origin - aimPosition).sqrMagnitude <= rangeSquared));
	}

19 View Source File : MeshUtility.cs
License : Apache License 2.0
Project Creator : aivclab

static int GetMiddlePoint(int p1,
                              int p2,
                              ref List<Vector3> vertices,
                              ref Dictionary<long, int> cache,
                              float radius) {
      // first check if we have it already
      var first_is_smaller = p1 < p2;
      long smaller_index = first_is_smaller ? p1 : p2;
      long greater_index = first_is_smaller ? p2 : p1;
      var key = (smaller_index << 32) + greater_index;

      if (cache.TryGetValue(key : key, value : out var ret)) {
        return ret;
      }

      // not in cache, calculate it
      var point1 = vertices[index : p1];
      var point2 = vertices[index : p2];
      var middle = new Vector3(x : (point1.x + point2.x) / 2f,
                               y : (point1.y + point2.y) / 2f,
                               z : (point1.z + point2.z) / 2f);

      // add vertex makes sure point is on unit sphere
      var i = vertices.Count;
      vertices.Add(item : middle.normalized * radius);

      // store it, return index
      cache.Add(key : key, value : i);

      return i;
    }

19 View Source File : RoadGenerator.cs
License : Apache License 2.0
Project Creator : Aggrathon

public void AddNode(Vector3 node, float strength)
		{
			if(roadNodes == null)
			{
				roadNodes = new List<Vector3>();
				roadNodes.Add(node);
				strengths = new List<float>();
				strengths.Add(strength);
			}
			else
			{
				for (int i = 0; i < roadNodes.Count; i++)
				{
					if(roadNodes[i] == node)
					{
						if (strengths[i] < strength)
							strengths[i] = strength;
						return;
					}
				}
				roadNodes.Add(node);
				strengths.Add(strength);
			}
		}

19 View Source File : OVROverlayMeshGenerator.cs
License : MIT License
Project Creator : absurd-joy

public static void BuildCube(List<Vector3> verts, List<Vector2> uv, List<int> triangles, Vector3 position, Quaternion rotation, Vector3 scale, float worldScale = 800, int subQuads = 1, float expand_coef = 1.01f)
    {
        position = Quaternion.Inverse(rotation) * position;

        int vertsPerSide = (subQuads + 1) * (subQuads + 1);

        for (int i = 0; i < (int)CubeFace.COUNT; i++)
        {
            for(int j = 0; j < subQuads + 1; j++)
            {
                for(int k = 0; k < subQuads + 1; k++)
                {
                    float u = j / (float)subQuads;
                    float v = k / (float)subQuads;

                    uv.Add(GetCubeUV((CubeFace)i, new Vector2(u, v), expand_coef));
                    Vector3 vert = GetCubeVert((CubeFace)i, new Vector2(u, v), expand_coef);
                    vert.x = (worldScale * vert.x - position.x) / scale.x;
                    vert.y = (worldScale * vert.y - position.y) / scale.y;
                    vert.z = (worldScale * vert.z - position.z) / scale.z;
                    verts.Add(vert);
                }
            }

            for(int j = 0; j < subQuads; j++)
            {
                for(int k = 0; k < subQuads; k++)
                {
                    triangles.Add(vertsPerSide * i + ((j + 1) * (subQuads + 1)) + k);
                    triangles.Add(vertsPerSide * i + (j * (subQuads + 1)) + k);
                    triangles.Add(vertsPerSide * i + ((j + 1) * (subQuads + 1)) + k + 1);
                    triangles.Add(vertsPerSide * i + ((j + 1) * (subQuads + 1)) + k + 1);
                    triangles.Add(vertsPerSide * i + (j * (subQuads + 1)) + k);
                    triangles.Add(vertsPerSide * i + (j * (subQuads + 1)) + k + 1);
                }
            }
        }
    }

19 View Source File : MeshUtility.cs
License : Apache License 2.0
Project Creator : aivclab

public static Mesh GenerateSpotlightCircleMesh(Camera main) {
      if (!main) {
        return null;
      }

      const int circle_segment_count = 64;
      const int circle_vertex_count = circle_segment_count + 2;
      const int circle_index_count = circle_segment_count * 3;
      const Single segment_width = Mathf.PI * 2f / circle_segment_count;

      var circle = new Mesh();
      var vertices = new List<Vector3>(capacity : circle_vertex_count);
      var indices = new int[circle_index_count];

      var angle = 0f;
      vertices.Add(item : Vector3.zero);
      for (var i = 1; i < circle_vertex_count; ++i) {
        vertices.Add(item : new Vector3(x : Mathf.Cos(f : angle), y : Mathf.Sin(f : angle), 0f));
        angle -= segment_width;
        if (i > 1) {
          var j = (i - 2) * 3;
          indices[j + 0] = 0;
          indices[j + 1] = i - 1;
          indices[j + 2] = i;
        }
      }

      circle.SetVertices(inVertices : vertices);
      circle.SetIndices(indices : indices, topology : MeshTopology.Triangles, 0);


      //var x1 = Mathf.Tan(main.fieldOfView * 0.5f * Mathf.Deg2Rad) * main.aspect * main.nearClipPlane;
      //var y1 = Mathf.Tan(main.fieldOfView * 0.5f * Mathf.Deg2Rad) * main.nearClipPlane;
      //var z1 = main.nearClipPlane;

      //normals
      var normals_list = new List<Vector3>();
      for (var i = 0; i < vertices.Count; i++) {
        normals_list.Add(item : Vector3.forward);
      }

      circle.SetNormals(inNormals : normals_list);
      //circle.RecalculateNormals();
      circle.RecalculateBounds();
      //circle.Optimize();
      return circle;
    }

19 View Source File : ParticlePainter.cs
License : MIT License
Project Creator : 734843327

public void ARFrameUpdated(UnityARCamera camera)
    {
        Matrix4x4 matrix = new Matrix4x4();
        matrix.SetColumn(3, camera.worldTransform.column3);
      
        Vector3 currentPositon = UnityARMatrixOps.GetPosition(matrix) + (Camera.main.transform.forward * penDistance);
        if (Vector3.Distance (currentPositon, previousPosition) > minDistanceThreshold) {
            if (paintMode == 2) currentPaintVertices.Add (currentPositon);
            frameUpdated = true;
            previousPosition = currentPositon;
        }
    }

19 View Source File : MeshUtility.cs
License : Apache License 2.0
Project Creator : aivclab

public static Mesh GenerateSpotlightCircleMesh2( Camera main, float radius = 1f, int n = 60) {
      if (!main) {
        return null;
      }
      var mesh = new Mesh();

      var vertices_list = new List<Vector3> { };
      float x;
      float y;
      for (var i = 0; i < n; i++) {
        x = radius * Mathf.Sin(f : (2 * Mathf.PI * i) / n);
        y = radius * Mathf.Cos(f : (2 * Mathf.PI * i) / n);
        vertices_list.Add(item : new Vector3(x : x, y : y, 0f));
      }

      var vertices = vertices_list.ToArray();

      //triangles
      var triangles_list = new List<int> { };
      for (var i = 0; i < (n - 2); i++) {
        triangles_list.Add(0);
        triangles_list.Add(item : i + 1);
        triangles_list.Add(item : i + 2);
      }

      var triangles = triangles_list.ToArray();

      var x1 = Mathf.Tan(f : main.fieldOfView * 0.5f * Mathf.Deg2Rad) * main.aspect * main.nearClipPlane;
      var y1 = Mathf.Tan(f : main.fieldOfView * 0.5f * Mathf.Deg2Rad) * main.nearClipPlane;
      var z1 = main.nearClipPlane;

      //normals
      var normals_list = new List<Vector3> { };
      for (var i = 0; i < vertices.Length; i++) {
        normals_list.Add(item : Vector3.forward);
      }

      var normals = normals_list.ToArray();

      //initialise
      mesh.vertices = vertices;
      mesh.triangles = triangles;
      mesh.normals = normals;

      return mesh;
    }

19 View Source File : OVROverlayMeshGenerator.cs
License : MIT License
Project Creator : absurd-joy

public static void BuildHemicylinder(List<Vector3> verts, List<Vector2> uv, List<int> triangles, Vector3 scale, Rect rect, int longitudes = 128)
    {
        float height = Mathf.Abs(scale.y) * rect.height;
        float radius = scale.z;
        float arcLength = scale.x * rect.width;

        float arcAngle = arcLength / radius;
        float minAngle = scale.x * (-0.5f + rect.x) / radius;
        
        int columns = Mathf.CeilToInt(longitudes * arcAngle / (2 * Mathf.PI));

        // we don't want super tall skinny triangles because that can lead to artifacting.
        // make triangles no more than 2x taller than wide

        float triangleWidth = arcLength / columns;
        float ratio = height / triangleWidth;

        int rows = Mathf.CeilToInt(ratio / 2);

        for (int j = 0; j < rows + 1; j += 1)
        {
            for (int k = 0; k < columns + 1; k++)
            {
                uv.Add(new Vector2((k / (float)columns), 1 - (j / (float)rows)));

                Vector3 vert = Vector3.zero;
                // because the scale is used to control the parameters, we need
                // to reverse multiply by scale to appear correctly
                vert.x = (Mathf.Sin(minAngle + (k * arcAngle / columns)) * radius) / scale.x;

                vert.y = (0.5f - rect.y - rect.height + rect.height * (1 - j / (float)rows));
                vert.z = (Mathf.Cos(minAngle + (k * arcAngle / columns)) * radius) / scale.z;
                verts.Add(vert);
            }
        }

        for (int j = 0; j < rows; j++)
        {
            for (int k = 0; k < columns; k++)
            {
                triangles.Add((j * (columns + 1)) + k);
                triangles.Add(((j + 1) * (columns + 1)) + k + 1);
                triangles.Add(((j + 1) * (columns + 1)) + k);
                triangles.Add(((j + 1) * (columns + 1)) + k + 1);
                triangles.Add((j * (columns + 1)) + k);
                triangles.Add((j * (columns + 1)) + k + 1);
            }
        }
    }

19 View Source File : ComplexThrowable.cs
License : MIT License
Project Creator : ajayyy

private void PhysicsAttach( Hand hand )
		{
			PhysicsDetach( hand );

			Rigidbody holdingBody = null;
			Vector3 holdingPoint = Vector3.zero;

			// The hand should grab onto the nearest rigid body
			float closestDistance = float.MaxValue;
			for ( int i = 0; i < rigidBodies.Count; i++ )
			{
				float distance = Vector3.Distance( rigidBodies[i].worldCenterOfMreplaced, hand.transform.position );
				if ( distance < closestDistance )
				{
					holdingBody = rigidBodies[i];
					closestDistance = distance;
				}
			}

			// Couldn't grab onto a body
			if ( holdingBody == null )
				return;

			// Create a fixed joint from the hand to the holding body
			if ( attachMode == AttachMode.FixedJoint )
			{
				Rigidbody handRigidbody = Util.FindOrAddComponent<Rigidbody>( hand.gameObject );
				handRigidbody.isKinematic = true;

				FixedJoint handJoint = hand.gameObject.AddComponent<FixedJoint>();
				handJoint.connectedBody = holdingBody;
			}

			// Don't let the hand interact with other things while it's holding us
			hand.HoverLock( null );

			// Affix this point
			Vector3 offset = hand.transform.position - holdingBody.worldCenterOfMreplaced;
			offset = Mathf.Min( offset.magnitude, 1.0f ) * offset.normalized;
			holdingPoint = holdingBody.transform.InverseTransformPoint( holdingBody.worldCenterOfMreplaced + offset );

			hand.AttachObject( this.gameObject, attachmentFlags );

			// Update holding list
			holdingHands.Add( hand );
			holdingBodies.Add( holdingBody );
			holdingPoints.Add( holdingPoint );
		}

19 View Source File : RuntimeGizmoManager.cs
License : MIT License
Project Creator : 39M

private void generateMeshes() {
      _cubeMesh = new Mesh();
      _cubeMesh.name = "RuntimeGizmoCube";
      _cubeMesh.hideFlags = HideFlags.HideAndDontSave;

      List<Vector3> verts = new List<Vector3>();
      List<int> indexes = new List<int>();

      Vector3[] faces = new Vector3[] { Vector3.forward, Vector3.right, Vector3.up };
      for (int i = 0; i < 3; i++) {
        addQuad(verts, indexes, faces[(i + 0) % 3], -faces[(i + 1) % 3], faces[(i + 2) % 3]);
        addQuad(verts, indexes, -faces[(i + 0) % 3], faces[(i + 1) % 3], faces[(i + 2) % 3]);
      }

      _cubeMesh.SetVertices(verts);
      _cubeMesh.SetIndices(indexes.ToArray(), MeshTopology.Quads, 0);
      _cubeMesh.RecalculateNormals();
      _cubeMesh.RecalculateBounds();
      _cubeMesh.UploadMeshData(true);

      _wireCubeMesh = new Mesh();
      _wireCubeMesh.name = "RuntimeWireCubeMesh";
      _wireCubeMesh.hideFlags = HideFlags.HideAndDontSave;

      verts.Clear();
      indexes.Clear();

      for (int dx = 1; dx >= -1; dx -= 2) {
        for (int dy = 1; dy >= -1; dy -= 2) {
          for (int dz = 1; dz >= -1; dz -= 2) {
            verts.Add(0.5f * new Vector3(dx, dy, dz));
          }
        }
      }

      addCorner(indexes, 0, 1, 2, 4);
      addCorner(indexes, 3, 1, 2, 7);
      addCorner(indexes, 5, 1, 4, 7);
      addCorner(indexes, 6, 2, 4, 7);

      _wireCubeMesh.SetVertices(verts);
      _wireCubeMesh.SetIndices(indexes.ToArray(), MeshTopology.Lines, 0);
      _wireCubeMesh.RecalculateBounds();
      _wireCubeMesh.UploadMeshData(true);

      _wireSphereMesh = new Mesh();
      _wireSphereMesh.name = "RuntimeWireSphereMesh";
      _wireSphereMesh.hideFlags = HideFlags.HideAndDontSave;

      verts.Clear();
      indexes.Clear();

      int totalVerts = CIRCLE_RESOLUTION * 3;
      for (int i = 0; i < CIRCLE_RESOLUTION; i++) {
        float angle = Mathf.PI * 2 * i / CIRCLE_RESOLUTION;
        float dx = 0.5f * Mathf.Cos(angle);
        float dy = 0.5f * Mathf.Sin(angle);

        for (int j = 0; j < 3; j++) {
          indexes.Add((i * 3 + j + 0) % totalVerts);
          indexes.Add((i * 3 + j + 3) % totalVerts);
        }

        verts.Add(new Vector3(dx, dy, 0));
        verts.Add(new Vector3(0, dx, dy));
        verts.Add(new Vector3(dx, 0, dy));
      }

      _wireSphereMesh.SetVertices(verts);
      _wireSphereMesh.SetIndices(indexes.ToArray(), MeshTopology.Lines, 0);
      _wireSphereMesh.RecalculateBounds();
      _wireSphereMesh.UploadMeshData(true);
    }

19 View Source File : AstronautDirections.cs
License : MIT License
Project Creator : alen-smajic

void HandleDirectionsResponse(DirectionsResponse response)
		{
			if (null == response.Routes || response.Routes.Count < 1)
			{
				return;
			}

			var dat = new List<Vector3>();
			foreach (var point in response.Routes[0].Geometry)
			{
				dat.Add(Conversions.GeoToWorldPosition(point.x, point.y, _map.CenterMercator, _map.WorldRelativeScale).ToVector3xz());
			}

			callback(dat);
		}

19 View Source File : CharacterCapsule.cs
License : MIT License
Project Creator : absurd-joy

void Update ()
	{
	    if (_character == null)
	    {
	        _character = GetComponentInParent<CharacterController>();
	        if (_character == null)
	        {
	            return;
	        }
	    }

	    if (_height == _character.height 
            && _radius == _character.radius 
            && _subdivisionU == SubdivisionsU 
            && _subdivisionV == SubdivisionsV)
	    {
	        return;
	    }

        _height = _character.height;
	    _radius = _character.radius;
	    _subdivisionU = SubdivisionsU;
	    _subdivisionV = SubdivisionsV;

        List<Vector3> verts = new List<Vector3>();

        var vector = new Vector3(1,0,0);

        // Generate the mesh
        var topOffset = new Vector3(0, _height/2.0f - _radius, 0);
        var bottomOffset = new Vector3(0, _radius - _height/2.0f, 0);

        // Add all the necessary vertices
        verts.Add(new Vector3(0, _height/2.0f, 0));

	    for (int u = SubdivisionsU - 1; u >= 0; u--)
	    {
	        float uf = (float) u / (float) SubdivisionsU;
            for (int v = 0; v < SubdivisionsV; v++)
            {
                float vf = (float) v / (float) SubdivisionsV;
                var q = Quaternion.Euler(0, vf * 360.0f, uf * 90.0f);
                var vert = q * vector;
                vert *= _radius;
                var v1 = vert + topOffset;
                verts.Add(v1);
	        }
        }

	    for (int u = 0; u < SubdivisionsU; u++)
	    {
            float uf = (float)u / (float)SubdivisionsU;
	        for (int v = 0; v < SubdivisionsV; v++)
	        {
	            float vf = (float)v / (float)SubdivisionsV;
	            var q = Quaternion.Euler(0, vf * 360.0f + 180.0f, uf * 90.0f);
	            var vert = q * vector;
	            vert *= _radius;
	            var v2 = bottomOffset - vert;
	            verts.Add(v2);
	        }
	    }
	    verts.Add(new Vector3(0, -_height / 2.0f, 0));


        // Setup all the triangles

        List<int> tris = new List<int>();
	    int index;
	    int i;

        // top cap
	    for (int v = 0; v < SubdivisionsV; v++)
	    {
	        i = 0;
	        tris.Add(i);
	        tris.Add(v);
	        tris.Add(v+1);
	    }
	    tris.Add(0);
        tris.Add(SubdivisionsV);
	    tris.Add(1);

        // top hemisphere
        for (int u = 0; u < SubdivisionsU - 1; u++)
	    {
	        index = u * SubdivisionsV + 1;
	        for (int v = 0; v < SubdivisionsV - 1; v++)
            {
                i = index + v;
                tris.Add(i);
                tris.Add(i + SubdivisionsV);
                tris.Add(i + 1);

                tris.Add(i + 1);
                tris.Add(i + SubdivisionsV);
                tris.Add(i + SubdivisionsV + 1);
           }
	        i = index + SubdivisionsV - 1;
	        tris.Add(i);
	        tris.Add(i + SubdivisionsV);
	        tris.Add(i + 1 - SubdivisionsV);

            tris.Add(i + 1 - SubdivisionsV);
            tris.Add(i + SubdivisionsV);
	        tris.Add(i + 1);
        }

        // center tube
        index = (SubdivisionsU - 1) * SubdivisionsV + 1;
	    for (int v = 0; v < SubdivisionsV - 1; v++)
	    {
	        i = index + v;
	        tris.Add(i);
	        tris.Add(i + SubdivisionsV);
	        tris.Add(i + 1);

	        tris.Add(i + 1);
	        tris.Add(i + SubdivisionsV);
	        tris.Add(i + SubdivisionsV + 1);
	    }
	    i = index + SubdivisionsV - 1;
	    tris.Add(i);
	    tris.Add(i + SubdivisionsV);
	    tris.Add(i + 1 - SubdivisionsV);

	    tris.Add(i + 1 - SubdivisionsV);
	    tris.Add(i + SubdivisionsV);
	    tris.Add(i + 1);

        // bottom hemisphere
        for (int u = 0; u < SubdivisionsU - 1; u++)
	    {
	        index = u * SubdivisionsV + (SubdivisionsU * SubdivisionsV) + 1;
	        for (int v = 0; v < SubdivisionsV - 1; v++)
	        {
	            i = index + v;
	            tris.Add(i);
	            tris.Add(i + SubdivisionsV);
	            tris.Add(i + 1);

	            tris.Add(i + 1);
	            tris.Add(i + SubdivisionsV);
	            tris.Add(i + SubdivisionsV + 1);
	        }
	        i = index + SubdivisionsV - 1;
	        tris.Add(i);
	        tris.Add(i + SubdivisionsV);
	        tris.Add(i + 1 - SubdivisionsV);

	        tris.Add(i + 1 - SubdivisionsV);
	        tris.Add(i + SubdivisionsV);
	        tris.Add(i + 1); 
	    }

        // bottom cap
	    var last = verts.Count - 1;
	    var lastRow = last - SubdivisionsV;
	    for (int v = 0; v < SubdivisionsV; v++)
	    {
	        i = 0;
	        tris.Add(last);
	        tris.Add(lastRow + v + 1);
	        tris.Add(lastRow + v);
	    }
	    tris.Add(last);
	    tris.Add(lastRow);
	    tris.Add(last - 1);


        _vertices = verts.ToArray();
	    _triangles = tris.ToArray();

	    _meshFilter = gameObject.GetComponent<MeshFilter>();
        _meshFilter.mesh = new Mesh();
        _meshFilter.sharedMesh.vertices = _vertices;
	    _meshFilter.sharedMesh.triangles = _triangles;
        _meshFilter.sharedMesh.RecalculateNormals();
	}

19 View Source File : LoftModifier.cs
License : MIT License
Project Creator : alen-smajic

public override void Run(VectorFeatureUnity feature, MeshData md, UnityTile tile = null)
		{
			if (feature.Points.Count < 1)
				return;

			foreach (var roadSegment in feature.Points)
			{
				_counter = roadSegment.Count;
				if (_counter <= 1)
					continue;

				var vl = new List<Vector3>(_sliceCount * _counter);
				var edges = new List<Vector3>(_counter);
				int co = 0;

				for (int j = 0; j < _counter; j++)
				{
					var current = Constants.Math.Vector3Zero;

					current = roadSegment[j];
					Vector3 dirCurrent, dir1, dir2;
					if (j > 0 && j < (_counter - 1))
					{
						dir1 = (roadSegment[j] - roadSegment[j - 1]).normalized;
						dir2 = (roadSegment[j + 1] - roadSegment[j]).normalized;
						dirCurrent = (dir2 + dir1).normalized;
					}
					else if (j == 0) //first
					{
						dirCurrent = (roadSegment[j + 1] - roadSegment[j]).normalized;
					}
					else //last
					{
						dirCurrent = (roadSegment[j] - roadSegment[j - 1]).normalized;
					}
					var q = Quaternion.LookRotation(dirCurrent);

					co = _slice.Count;
					for (int i = 0; i < co; i++)
					{
						var p = q * _slice[i];
						vl.Add(p + current);
						if (i == co - 1) //last item capped
						{
							edges.Add(p + current);
						}
					}
				}

				if (md.Triangles.Count == 0)
				{
					md.Triangles.Add(new List<int>());
				}
				md.Vertices.Capacity = md.Vertices.Count + (vl.Count - _sliceCount) * 4;
				md.Normals.Capacity = md.Normals.Count + (vl.Count - _sliceCount) * 4;
				md.Triangles.Capacity = md.Triangles.Count + (vl.Count - _sliceCount) * 6;
				
				var uvDist = 0f;
				float edMag = 0f, h = 0f;
				co = 0;
				Vector3 norm;

				for (int i = 0; i < _counter - 1; i++)
				{
					for (int j = 0; j < _sliceCount - 1; j++)
					{
						var ind = i * _sliceCount + j;
						var ed = vl[ind + _sliceCount] - vl[ind];
						edMag = ed.magnitude;
						co = md.Vertices.Count;
						norm = Vector3.Cross(vl[ind] - vl[ind + 1], vl[ind + _sliceCount] - vl[ind]).normalized;
						md.Vertices.Add(vl[ind]);
						md.Vertices.Add(vl[ind + 1]);
						md.Vertices.Add(vl[ind + _sliceCount]);
						md.Vertices.Add(vl[ind + _sliceCount + 1]);

						h = (float)j / _sliceCount;

						md.UV[0].Add(new Vector2(uvDist, ((float)j - 1) / _sliceCount));
						md.UV[0].Add(new Vector2(uvDist, h));
						md.UV[0].Add(new Vector2(uvDist + edMag, ((float)j - 1) / _sliceCount));
						md.UV[0].Add(new Vector2(uvDist + edMag, h));

						md.Tangents.Add(new Vector4(ed.normalized.x, ed.normalized.y, ed.normalized.z, 1));
						md.Tangents.Add(new Vector4(ed.normalized.x, ed.normalized.y, ed.normalized.z, 1));
						md.Tangents.Add(new Vector4(ed.normalized.x, ed.normalized.y, ed.normalized.z, 1));
						md.Tangents.Add(new Vector4(ed.normalized.x, ed.normalized.y, ed.normalized.z, 1));

						md.Normals.Add(norm);
						md.Normals.Add(norm);
						md.Normals.Add(norm);
						md.Normals.Add(norm);

						md.Triangles[0].Add(co);
						md.Triangles[0].Add(co + 2);
						md.Triangles[0].Add(co + 1);

						md.Triangles[0].Add(co + 1);
						md.Triangles[0].Add(co + 2);
						md.Triangles[0].Add(co + 3);
					}
					uvDist += edMag;
				}

				if (_closeEdges && edges.Count > 2)
				{
					if (md.Triangles.Count < 2)
					{
						md.Triangles.Add(new List<int>());
					}

					var flatData = EarcutLibrary.Flatten(new List<List<Vector3>>() { edges });
					var result = EarcutLibrary.Earcut(flatData.Vertices, flatData.Holes, flatData.Dim);

					md.Triangles[1].AddRange(result.Select(x => md.Vertices.Count + x).ToList());
					for (int i = 0; i < edges.Count; i++)
					{
						md.Vertices.Add(edges[i]);
						md.Normals.Add(Constants.Math.Vector3Up);
						md.UV[0].Add(new Vector2(edges[i].x, edges[i].z));
						md.Tangents.Add(new Vector4(1,0,0,1));
					}
				}
			}
		}

19 View Source File : StripMeshLineRenderer.cs
License : Apache License 2.0
Project Creator : abist-co-ltd

protected override void UpdateLine()
        {
            if (stripMeshRenderer == null)
            {
                Debug.LogError("Strip mesh renderer has been destroyed - disabling");
                enabled = false;
            }

            if (!LineDataSource.enabled)
            {
                stripMeshRenderer.enabled = false;
                return;
            }

            stripMeshRenderer.enabled = true;
            positions.Clear();
            forwards.Clear();
            colors.Clear();
            widths.Clear();
            
            for (int i = 0; i <= LineStepCount; i++)
            {
                float normalizedDistance = GetNormalizedPointAlongLine(i);
                positions.Add(LineDataSource.GetPoint(normalizedDistance));
                colors.Add(GetColor(normalizedDistance));
                widths.Add(GetWidth(normalizedDistance));
                forwards.Add(LineDataSource.GetVelocity(normalizedDistance));
            }

            GenerateStripMesh(positions, colors, widths, uvOffset, forwards, stripMesh, LineDataSource.LineTransform.up);
        }

19 View Source File : ElevatedTerrainWithSidesStrategy.cs
License : MIT License
Project Creator : alen-smajic

private void CreateBaseMesh(UnityTile tile)
		{
			//TODO use arrays instead of lists
			_newVertexList.Clear();
			_newNormalList.Clear();
			_newUvList.Clear();
			_newTriangleList.Clear();

			var _sampleCount = _elevationOptions.modificationOptions.sampleCount;
			for (float y = 0; y < _sampleCount; y++)
			{
				var yrat = y / (_sampleCount - 1);
				for (float x = 0; x < _sampleCount; x++)
				{
					var xrat = x / (_sampleCount - 1);

					var xx = Mathd.Lerp(tile.Rect.Min.x, tile.Rect.Max.x, xrat);
					var yy = Mathd.Lerp(tile.Rect.Min.y, tile.Rect.Max.y, yrat);

					_newVertexList.Add(new Vector3(
						(float)(xx - tile.Rect.Center.x) * tile.TileScale,
						0,
						(float)(yy - tile.Rect.Center.y) * tile.TileScale));
					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);
					_newUvList.Add(new Vector2(x * 1f / (_sampleCount - 1), 1 - (y * 1f / (_sampleCount - 1))));
				}
			}

			int vertA, vertB, vertC;
			for (int y = 0; y < _sampleCount - 1; y++)
			{
				for (int x = 0; x < _sampleCount - 1; x++)
				{
					vertA = (y * _sampleCount) + x;
					vertB = (y * _sampleCount) + x + _sampleCount + 1;
					vertC = (y * _sampleCount) + x + _sampleCount;
					_newTriangleList.Add(vertA);
					_newTriangleList.Add(vertB);
					_newTriangleList.Add(vertC);

					vertA = (y * _sampleCount) + x;
					vertB = (y * _sampleCount) + x + 1;
					vertC = (y * _sampleCount) + x + _sampleCount + 1;
					_newTriangleList.Add(vertA);
					_newTriangleList.Add(vertB);
					_newTriangleList.Add(vertC);
				}
			}

			var sideVertBase = _newVertexList.Count;

			var lastRow = (_sampleCount - 1) * _sampleCount;
			var baseTriList = new List<int>();
			for (int x = 0; x < _sampleCount; x++)
			{
				//side wall
				//024
				//135
				_newVertexList.Add(_newVertexList[x]);
				_newVertexList.Add(new Vector3(
					_newVertexList[x].x,
					-_elevationOptions.sideWallOptions.wallHeight,
					_newVertexList[x].z));
				_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Forward);
				_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Forward);
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 1));
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 0));

				//---

				_newVertexList.Add(_newVertexList[x * _sampleCount]);
				_newVertexList.Add(new Vector3(
						_newVertexList[x * _sampleCount].x,
					-_elevationOptions.sideWallOptions.wallHeight,
						_newVertexList[x * _sampleCount].z));
				_newNormalList.Add(Vector3.left);
				_newNormalList.Add(Vector3.left);
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 1));
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 0));

				//---

				_newVertexList.Add(_newVertexList[(x + 1) * _sampleCount - 1]);
				_newVertexList.Add(new Vector3(
						_newVertexList[(x + 1) * _sampleCount - 1].x,
					-_elevationOptions.sideWallOptions.wallHeight,
						_newVertexList[(x + 1) * _sampleCount - 1].z));
				_newNormalList.Add(Vector3.right);
				_newNormalList.Add(Vector3.right);
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 1));
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 0));

				//---

				_newVertexList.Add(_newVertexList[lastRow + x]);
				_newVertexList.Add(new Vector3(
					_newVertexList[lastRow + x].x,
					-_elevationOptions.sideWallOptions.wallHeight,
					_newVertexList[lastRow + x].z));
				_newNormalList.Add(Vector3.back);
				_newNormalList.Add(Vector3.back);
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 1));
				_newUvList.Add(new Vector2(_newUvList[x * _sampleCount].y, 0));

				if (x > 0)
				{
					baseTriList.Add(sideVertBase + 8 * x);
					baseTriList.Add(sideVertBase + 8 * x - 8);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1);

					baseTriList.Add(sideVertBase + 8 * x);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1);
					baseTriList.Add(sideVertBase + 8 * x + 1);

					//---

					baseTriList.Add(sideVertBase + 8 * x + 2);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1 + 2);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 2);

					baseTriList.Add(sideVertBase + 8 * x + 2);
					baseTriList.Add(sideVertBase + 8 * x + 1 + 2);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1 + 2);

					//---

					baseTriList.Add(sideVertBase + 8 * x + 4);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 4);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1 + 4);

					baseTriList.Add(sideVertBase + 8 * x + 4);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1 + 4);
					baseTriList.Add(sideVertBase + 8 * x + 1 + 4);

					//---

					baseTriList.Add(sideVertBase + 8 * x + 6);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1 + 6);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 6);

					baseTriList.Add(sideVertBase + 8 * x + 6);
					baseTriList.Add(sideVertBase + 8 * x + 1 + 6);
					baseTriList.Add(sideVertBase + 8 * x - 8 + 1 + 6);
				}
			}


			var mesh = tile.MeshFilter.mesh;
			mesh.SetVertices(_newVertexList);
			mesh.SetNormals(_newNormalList);
			mesh.SetUVs(0, _newUvList);
			mesh.subMeshCount = 2;
			mesh.SetTriangles(_newTriangleList, 0);
			mesh.SetTriangles(baseTriList, 1);
		}

19 View Source File : Polygon.cs
License : GNU Affero General Public License v3.0
Project Creator : ACEmulator

public void BuildPolygon(ModelPolygon _poly, Vector3 position, Quaternion orientation, float scalar = 1.0f)
        {
            Vertices = new List<Vector3>();

            // build the matrix transform
            var transform = Matrix4x4.CreateScale(scalar) * Matrix4x4.CreateFromQuaternion(orientation) * Matrix4x4.CreateTranslation(position);

            // transform the vertices
            // from local object to world space
            foreach (var vertex in _poly.Vertices)
            {
                Vertices.Add(Vector3.Transform(vertex.Origin, transform));
            }
        }

19 View Source File : LowPolyTerrainStrategy.cs
License : MIT License
Project Creator : alen-smajic

private void CreateBaseMesh(UnityTile tile)
		{
			//TODO use arrays instead of lists
			_newVertexList.Clear();
			_newNormalList.Clear();
			_newUvList.Clear();
			_newTriangleList.Clear();

			var cap = (_elevationOptions.modificationOptions.sampleCount - 1);
			for (float y = 0; y < cap; y++)
			{
				for (float x = 0; x < cap; x++)
				{
					var x1 = tile.TileScale * (float)(Mathd.Lerp(tile.Rect.Min.x, tile.Rect.Max.x, x / cap) - tile.Rect.Center.x);
					var y1 = tile.TileScale * (float)(Mathd.Lerp(tile.Rect.Min.y, tile.Rect.Max.y, y / cap) - tile.Rect.Center.y);
					var x2 = tile.TileScale * (float)(Mathd.Lerp(tile.Rect.Min.x, tile.Rect.Max.x, (x + 1) / cap) - tile.Rect.Center.x);
					var y2 = tile.TileScale * (float)(Mathd.Lerp(tile.Rect.Min.y, tile.Rect.Max.y, (y + 1) / cap) - tile.Rect.Center.y);

					var triStart = _newVertexList.Count;
					_newVertexList.Add(new Vector3(x1, 0, y1));
					_newVertexList.Add(new Vector3(x2, 0, y1));
					_newVertexList.Add(new Vector3(x1, 0, y2));
					//--
					_newVertexList.Add(new Vector3(x2, 0, y1));
					_newVertexList.Add(new Vector3(x2, 0, y2));
					_newVertexList.Add(new Vector3(x1, 0, y2));

					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);
					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);
					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);
					//--
					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);
					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);
					_newNormalList.Add(Mapbox.Unity.Constants.Math.Vector3Up);


					_newUvList.Add(new Vector2(x / cap, 1 - y / cap));
					_newUvList.Add(new Vector2((x + 1) / cap, 1 - y / cap));
					_newUvList.Add(new Vector2(x / cap, 1 - (y + 1) / cap));
					//--
					_newUvList.Add(new Vector2((x + 1) / cap, 1 - y / cap));
					_newUvList.Add(new Vector2((x + 1) / cap, 1 - (y + 1) / cap));
					_newUvList.Add(new Vector2(x / cap, 1 - (y + 1) / cap));

					_newTriangleList.Add(triStart);
					_newTriangleList.Add(triStart + 1);
					_newTriangleList.Add(triStart + 2);
					//--
					_newTriangleList.Add(triStart + 3);
					_newTriangleList.Add(triStart + 4);
					_newTriangleList.Add(triStart + 5);
				}
			}


			var mesh = tile.MeshFilter.sharedMesh;
			mesh.indexFormat = IndexFormat.UInt32;
			mesh.SetVertices(_newVertexList);
			mesh.SetNormals(_newNormalList);
			mesh.SetUVs(0, _newUvList);
			mesh.SetTriangles(_newTriangleList, 0);
			mesh.RecalculateBounds();
		}

19 View Source File : RuntimeGizmoManager.cs
License : MIT License
Project Creator : 39M

private void generateMeshes() {
      _cubeMesh = new Mesh();
      _cubeMesh.name = "RuntimeGizmoCube";
      _cubeMesh.hideFlags = HideFlags.HideAndDontSave;

      List<Vector3> verts = new List<Vector3>();
      List<int> indexes = new List<int>();

      Vector3[] faces = new Vector3[] { Vector3.forward, Vector3.right, Vector3.up };
      for (int i = 0; i < 3; i++) {
        addQuad(verts, indexes, faces[(i + 0) % 3], -faces[(i + 1) % 3], faces[(i + 2) % 3]);
        addQuad(verts, indexes, -faces[(i + 0) % 3], faces[(i + 1) % 3], faces[(i + 2) % 3]);
      }

      _cubeMesh.SetVertices(verts);
      _cubeMesh.SetIndices(indexes.ToArray(), MeshTopology.Quads, 0);
      _cubeMesh.RecalculateNormals();
      _cubeMesh.RecalculateBounds();
      _cubeMesh.UploadMeshData(true);

      _wireCubeMesh = new Mesh();
      _wireCubeMesh.name = "RuntimeWireCubeMesh";
      _wireCubeMesh.hideFlags = HideFlags.HideAndDontSave;

      verts.Clear();
      indexes.Clear();

      for (int dx = 1; dx >= -1; dx -= 2) {
        for (int dy = 1; dy >= -1; dy -= 2) {
          for (int dz = 1; dz >= -1; dz -= 2) {
            verts.Add(0.5f * new Vector3(dx, dy, dz));
          }
        }
      }

      addCorner(indexes, 0, 1, 2, 4);
      addCorner(indexes, 3, 1, 2, 7);
      addCorner(indexes, 5, 1, 4, 7);
      addCorner(indexes, 6, 2, 4, 7);

      _wireCubeMesh.SetVertices(verts);
      _wireCubeMesh.SetIndices(indexes.ToArray(), MeshTopology.Lines, 0);
      _wireCubeMesh.RecalculateBounds();
      _wireCubeMesh.UploadMeshData(true);

      _wireSphereMesh = new Mesh();
      _wireSphereMesh.name = "RuntimeWireSphereMesh";
      _wireSphereMesh.hideFlags = HideFlags.HideAndDontSave;

      verts.Clear();
      indexes.Clear();

      int totalVerts = CIRCLE_RESOLUTION * 3;
      for (int i = 0; i < CIRCLE_RESOLUTION; i++) {
        float angle = Mathf.PI * 2 * i / CIRCLE_RESOLUTION;
        float dx = 0.5f * Mathf.Cos(angle);
        float dy = 0.5f * Mathf.Sin(angle);

        for (int j = 0; j < 3; j++) {
          indexes.Add((i * 3 + j + 0) % totalVerts);
          indexes.Add((i * 3 + j + 3) % totalVerts);
        }

        verts.Add(new Vector3(dx, dy, 0));
        verts.Add(new Vector3(0, dx, dy));
        verts.Add(new Vector3(dx, 0, dy));
      }

      _wireSphereMesh.SetVertices(verts);
      _wireSphereMesh.SetIndices(indexes.ToArray(), MeshTopology.Lines, 0);
      _wireSphereMesh.RecalculateBounds();
      _wireSphereMesh.UploadMeshData(true);
    }

19 View Source File : SmoothLineModifier.cs
License : MIT License
Project Creator : alen-smajic

public override void Run(VectorFeatureUnity feature, MeshData md, UnityTile tile = null)
        {
			_counter = feature.Points.Count;

			for (int i = 0; i < _counter; i++)
            {
                var nl = new List<Vector3>();
				_counter2 = feature.Points[i].Count;
				for (int j = 1; j < _counter2; j++)
                {
                    nl.Add(feature.Points[i][j - 1]);
                    var dist = Vector3.Distance(feature.Points[i][j - 1], feature.Points[i][j]);
                    var step = Math.Min(_maxEdgeSectionCount, dist / _preferredEdgeSectionLength);
                    if (step > 1)
                    {
                        var counter = 1;
                        while (counter < step)
                        {
                            var nv = Vector3.Lerp(feature.Points[i][j - 1], feature.Points[i][j], Mathf.Min(1, counter / step));
                            nl.Add(nv);
                            counter++;
                        }
                    }
                    nl.Add(feature.Points[i][j]);
                }
                feature.Points[i] = nl;
            }
        }

19 View Source File : Setup.cs
License : GNU General Public License v3.0
Project Creator : ACEmulator

public List<Vector3> GetVertices()
        {
            var verts = new List<Vector3>();

            for (var i = 0; i < Parts.Count; i++)
            {
                if (Parts[i]._gfxObj.Id == 0x010001EC)
                    continue;

                var part = Parts[i];
                var placementFrame = PlacementFrames[i];

                var partVerts = part.VertexArray.Select(v => v.Position).ToList();

                foreach (var partVert in partVerts)
                    verts.Add(Vector3.Transform(partVert, placementFrame));
            }
            return verts;
        }

19 View Source File : BoundingBoxHelper.cs
License : Apache License 2.0
Project Creator : abist-co-ltd

public void UpdateNonAABoundsCornerPositions(BoxCollider colliderBounds, List<Vector3> boundsPoints)
        {
            if (colliderBounds != targetBounds || rawBoundingCornersObtained == false)
            {
                GetRawBoundsCorners(colliderBounds);
            }

            if (colliderBounds == targetBounds && rawBoundingCornersObtained)
            {
                boundsPoints.Clear();
                for (int i = 0; i < rawBoundingCorners.Count; ++i)
                {
                    boundsPoints.Add(colliderBounds.transform.localToWorldMatrix.MultiplyPoint(rawBoundingCorners[i]));
                }

                worldBoundingCorners.Clear();
                worldBoundingCorners.AddRange(boundsPoints);
            }
        }

19 View Source File : CapsuleHand.cs
License : MIT License
Project Creator : 39M

private Mesh generateCylinderMesh(float length) {
      Mesh mesh = new Mesh();
      mesh.name = "GeneratedCylinder";
      mesh.hideFlags = HideFlags.DontSave;

      List<Vector3> verts = new List<Vector3>();
      List<Color> colors = new List<Color>();
      List<int> tris = new List<int>();

      Vector3 p0 = Vector3.zero;
      Vector3 p1 = Vector3.forward * length;
      for (int i = 0; i < _cylinderResolution; i++) {
        float angle = (Mathf.PI * 2.0f * i) / _cylinderResolution;
        float dx = CYLINDER_RADIUS * Mathf.Cos(angle);
        float dy = CYLINDER_RADIUS * Mathf.Sin(angle);

        Vector3 spoke = new Vector3(dx, dy, 0);

        verts.Add((p0 + spoke) * transform.lossyScale.x);
        verts.Add((p1 + spoke) * transform.lossyScale.x);

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

        int triStart = verts.Count;
        int triCap = _cylinderResolution * 2;

        tris.Add((triStart + 0) % triCap);
        tris.Add((triStart + 2) % triCap);
        tris.Add((triStart + 1) % triCap);

        tris.Add((triStart + 2) % triCap);
        tris.Add((triStart + 3) % triCap);
        tris.Add((triStart + 1) % triCap);
      }

      mesh.SetVertices(verts);
      mesh.SetIndices(tris.ToArray(), MeshTopology.Triangles, 0);
      mesh.RecalculateBounds();
      mesh.RecalculateNormals();
      ;
      mesh.UploadMeshData(true);

      return mesh;
    }

19 View Source File : RuntimeGizmoManager.cs
License : MIT License
Project Creator : 39M

private void addQuad(List<Vector3> verts, List<int> indexes, Vector3 normal, Vector3 axis1, Vector3 axis2) {
      indexes.Add(verts.Count + 0);
      indexes.Add(verts.Count + 1);
      indexes.Add(verts.Count + 2);
      indexes.Add(verts.Count + 3);

      verts.Add(0.5f * (normal + axis1 + axis2));
      verts.Add(0.5f * (normal + axis1 - axis2));
      verts.Add(0.5f * (normal - axis1 - axis2));
      verts.Add(0.5f * (normal - axis1 + axis2));
    }

19 View Source File : PlyHandler.cs
License : MIT License
Project Creator : 3DBear

private static List<Vector3> GetVertices(byte[] bytes, PlyHeader header, out List<Color> colors)
        {
            var vertices = new List<Vector3>();
            colors = new List<Color>();
            int bpvc = 4; // bytes per vertex component
            int bpcc = 1; // bytes per color component
            bool hasColor = header.RedIndex.HasValue && header.GreenIndex.HasValue && header.BlueIndex.HasValue;
            // todo: support other types than just float for vertex components and byte for color components
            int bytesPerVertex = GetByteCountPerVertex(header);

            for (int i = 0; i < header.VertexCount; i++)
            {
                int byteIndex = i * bytesPerVertex;
                var x = System.BitConverter.ToSingle(bytes.SubArray(byteIndex + 0 * bpvc, bpvc), 0);
                var y = System.BitConverter.ToSingle(bytes.SubArray(byteIndex + 1 * bpvc, bpvc), 0);
                var z = System.BitConverter.ToSingle(bytes.SubArray(byteIndex + 2 * bpvc, bpvc), 0);
                if (hasColor)
                {
                    byte r, g, b, a = 255;
                    r = bytes[byteIndex + 3 * bpvc + 0 * bpcc];
                    g = bytes[byteIndex + 3 * bpvc + 1 * bpcc];
                    b = bytes[byteIndex + 3 * bpvc + 2 * bpcc];
                    if (header.AlphaIndex.HasValue)
                    {
                        a = bytes[byteIndex + 3 * bpvc + 3 * bpcc];
                    }
                    colors.Add(new Color(r/255f, g/255f, b/255f, a/255f));
                }


                vertices.Add(new Vector3(x, y, z));
            }
            return vertices;
        }

19 View Source File : OVROverlayMeshGenerator.cs
License : MIT License
Project Creator : absurd-joy

public static void BuildSphere(List<Vector3> verts, List<Vector2> uv, List<int> triangles, Vector3 position, Quaternion rotation, Vector3 scale, Rect rect, float worldScale = 800, int lareplacedudes = 128, int longitudes = 128, float expand_coef = 1.0f)
    {
        position = Quaternion.Inverse(rotation) * position;

        lareplacedudes = Mathf.CeilToInt(lareplacedudes * rect.height);
        longitudes = Mathf.CeilToInt(longitudes * rect.width);

        float minTheta = Mathf.PI * 2 * ( rect.x);
        float minPhi = Mathf.PI * (0.5f - rect.y - rect.height);

        float thetaScale = Mathf.PI * 2 * rect.width / longitudes;
        float phiScale = Mathf.PI * rect.height / lareplacedudes;

        for (int j = 0; j < lareplacedudes + 1; j += 1)
        {
            for (int k = 0; k < longitudes + 1; k++)
            {
                float theta = minTheta + k * thetaScale;
                float phi = minPhi + j * phiScale;

                Vector2 suv = GetSphereUV(theta, phi, expand_coef);
                uv.Add(new Vector2((suv.x - rect.x) / rect.width, (suv.y - rect.y) / rect.height));
                Vector3 vert = GetSphereVert(theta, phi);
                vert.x = (worldScale * vert.x - position.x) / scale.x;
                vert.y = (worldScale * vert.y - position.y) / scale.y;
                vert.z = (worldScale * vert.z - position.z) / scale.z;
                verts.Add(vert);
            }
        }

        for (int j = 0; j < lareplacedudes; j++)
        {
            for (int k = 0; k < longitudes; k++)
            {
                triangles.Add((j * (longitudes + 1)) + k);
                triangles.Add(((j + 1) * (longitudes + 1)) + k);
                triangles.Add(((j + 1) * (longitudes + 1)) + k + 1);
                triangles.Add(((j + 1) * (longitudes + 1)) + k + 1);
                triangles.Add((j * (longitudes + 1)) + k + 1);
                triangles.Add((j * (longitudes + 1)) + k);
            }
        }
    }

19 View Source File : TraverserCharacterController.Private.cs
License : MIT License
Project Creator : AitorSimona

private void CheckGroundCollision()
        {
            int colliderIndex = CastGroundProbe();

            if (colliderIndex != -1)
            {   
                // --- Set the closest collider as our ground ---  
                current.ground = hitColliders[colliderIndex];
                current.isGrounded = true;
            }      

            // --- Add cast position to debug draw lists ---
            if (debugDraw)
            {
                if (probePositions.Count == simulationCounter)
                    probePositions.Add(position);
                else
                    probePositions[simulationCounter] = position;

                if (planePositions.Count == simulationCounter)
                    planePositions.Add(characterController.bounds.min + Vector3.forward * characterController.radius + Vector3.right * characterController.radius + Vector3.up * groundProbeRadius);
                else
                    planePositions[simulationCounter] = characterController.bounds.min + Vector3.forward * characterController.radius + Vector3.right * characterController.radius + Vector3.up * groundProbeRadius;
            }

            // --- Prevent drop/fall, snap to ground ---

            if (currentGroundSnap)
            {
                groundRay.origin = characterController.transform.position;
                groundRay.direction = -Vector3.up;

                if (state.previousCollision.ground != null 
                    && !Physics.Raycast(groundRay.origin, groundRay.direction, groundSnapRayDistance, characterCollisionMask, QueryTriggerInteraction.Ignore))
                {
                    // --- We want to slide along the edge of the collider, not get trapped on it, so we need to properly adjust the trajectory ---

                    // --- Obtain collider's closest point and compute a new velocity vector ---
                    Vector3 correctedPosition = state.previousCollision.position;
                    Vector3 closestColliderPosition = state.previousCollision.ground.ClosestPoint(state.currentCollision.position);
                    Vector3 correctedVelocityVector = closestColliderPosition - state.previousCollision.position;

                    // --- Project our current velocity on the newly computed velocity vector ---                   
                    Vector3 desiredVelocity = Vector3.Project(state.currentCollision.velocity, correctedVelocityVector);
                    correctedPosition += desiredVelocity * Time.deltaTime;
                    state.currentCollision.velocity = desiredVelocity / stepping;

                    // --- Manually correct controller's position ---
                    characterController.enabled = false;
                    transform.position = correctedPosition;
                    characterController.enabled = true;
                    state.currentCollision.position = transform.position;                   
                }

                // --- Draw casted ray ---
                if (debugDraw)
                    Debug.DrawRay(groundRay.origin, groundRay.direction * groundSnapRayDistance);
            }
        }

See More Examples