public static void RegenerateDebugLines(Vector3 seedPos, IvyRoot root) { root.debugLineSegmentsArray = new Vector3[(root.nodes.Count - 1) * 2]; var cache = IvyRoot.GetMeshCacheFor(root); int nodeCounter = 0; for (int i = 0; i < cache.debugLineSegmentsArray.Length; i += 2) { cache.debugLineSegmentsArray[i] = root.nodes[nodeCounter].p + seedPos; cache.debugLineSegmentsArray[i + 1] = root.nodes[nodeCounter + 1].p + seedPos; nodeCounter++; } }
public static void ForceIvyGrowth(IvyGraph graph, IvyProfile ivyProfile, Vector3 newPos, Vector3 newNormal) { newPos -= graph.seedPos; // convert to local space // find the nearest root end node, and continue off of it // var closestRoot = graph.roots.OrderBy( root => Vector3.Distance( newPos, root.nodes.Last().localPos ) ).FirstOrDefault(); // if ( closestRoot == null ) { // return; // } var closestRoot = graph.roots[0]; var lastNode = closestRoot.nodes[closestRoot.nodes.Count - 1]; var growVector = newPos - lastNode.p; var newNode = new IvyNode(); newNode.p = newPos; newNode.g = (0.5f * lastNode.g + 0.5f * growVector.normalized).normalized; //newNode.adhesionVector = ComputeAdhesion( newPos, ivyProfile ); //if ( newNode.adhesionVector.sqrMagnitude < 0.01f ) { newNode.c = -newNormal; //} newNode.s = lastNode.s + growVector.magnitude; newNode.cS = lastNode.cS + growVector.magnitude; newNode.fS = 0f; newNode.cl = true; closestRoot.nodes.Add(newNode); closestRoot.useCachedBranchData = false; closestRoot.useCachedLeafData = false; // TryGrowIvyBranch( graph, ivyProfile, closestRoot, newNode ); var cache = IvyRoot.GetMeshCacheFor(closestRoot); cache.debugLineSegmentsList.Add(lastNode.p + graph.seedPos); cache.debugLineSegmentsList.Add(newPos + graph.seedPos); cache.debugLineSegmentsArray = cache.debugLineSegmentsList.ToArray(); if (graph.generateMeshDuringGrowth) { IvyMesh.GenerateMesh(graph, ivyProfile); } }
public static void GrowIvyStep(IvyGraph graph, IvyProfile ivyProfile) { // if there are no longer any live roots, then we're dead if (graph.isGrowing) { graph.isGrowing = graph.roots.Where(root => root.isAlive).Count() > 0; } if (!graph.isGrowing) { return; } //lets grow foreach (var root in graph.roots) { //process only roots that are alive if (!root.isAlive) { continue; } IvyNode lastNode = root.nodes[root.nodes.Count - 1]; //let the ivy die, if the maximum float length is reached if (lastNode.cS > ivyProfile.maxLength || (lastNode.cS > Mathf.Max(root.forceMinLength, ivyProfile.minLength) && lastNode.fS > ivyProfile.maxFloatLength)) { // Debug.LogFormat("root death! cum dist: {0:F2}, floatLength {1:F2}", lastNode.lengthCumulative, lastNode.floatingLength); root.isAlive = false; SmoothGaussianAdhesion(root); continue; } //grow vectors: primary direction, random influence, and adhesion of scene objectss //primary vector = weighted sum of previous grow vectors plus a little bit upwards Vector3 primaryVector = Vector3.Normalize(lastNode.g * 2f + Vector3.up); //random influence plus a little upright vector Vector3 exploreVector = lastNode.p - root.nodes[0].p; if (exploreVector.magnitude > 1f) { exploreVector = exploreVector.normalized; } exploreVector *= Mathf.PingPong(root.nodes[0].p.sqrMagnitude * root.parents + lastNode.cS * 0.69f, 1f); Vector3 randomVector = (Random.onUnitSphere * 0.5f + exploreVector).normalized; //adhesion influence to the nearest triangle = weighted sum of previous adhesion vectors Vector3 adhesionVector = ComputeAdhesion(lastNode.p + graph.seedPos, ivyProfile); if (adhesionVector.sqrMagnitude <= 0.01f) { adhesionVector = lastNode.c; } //compute grow vector Vector3 growVector = ivyProfile.ivyStepDistance * Vector3.Normalize( primaryVector * ivyProfile.primaryWeight + randomVector * Mathf.Max(0.01f, ivyProfile.randomWeight) + adhesionVector * ivyProfile.adhesionWeight ); //gravity influence Vector3 gravityVector = ivyProfile.ivyStepDistance * Vector3.down * ivyProfile.gravityWeight; //gravity depends on the floating length gravityVector *= Mathf.Pow(lastNode.fS / ivyProfile.maxFloatLength, 0.7f); //next possible ivy node //climbing state of that ivy node, will be set during collision detection bool climbing = false; //compute position of next ivy node Vector3 newPos = lastNode.p + growVector + gravityVector; //combine alive state with result of the collision detection, e.g. let the ivy die in case of a collision detection problem Vector3 adhesionFromRaycast = adhesionVector; // convert newPos to world position, just for the collision calc newPos += graph.seedPos; root.isAlive = root.isAlive && ComputeCollision(0.01f, lastNode.p + graph.seedPos, ref newPos, ref climbing, ref adhesionFromRaycast, ivyProfile.collisionMask); newPos -= graph.seedPos; //update grow vector due to a changed newPos growVector = newPos - lastNode.p - gravityVector; // +graph.seedPos to convert back to world space var cache = IvyRoot.GetMeshCacheFor(root); cache.debugLineSegmentsList.Add(lastNode.p + graph.seedPos); cache.debugLineSegmentsList.Add(newPos + graph.seedPos); // cache line segments cache.debugLineSegmentsArray = cache.debugLineSegmentsList.ToArray(); //create next ivy node IvyNode newNode = new IvyNode(); newNode.p = newPos; newNode.g = (0.5f * lastNode.g + 0.5f * growVector.normalized).normalized; newNode.c = adhesionVector; //Vector3.Lerp(adhesionVector, adhesionFromRaycast, 0.5f); newNode.s = lastNode.s + (newPos - lastNode.p).magnitude; newNode.cS = lastNode.cS + (newPos - lastNode.p).magnitude; newNode.fS = climbing ? 0.0f : lastNode.fS + (newPos - lastNode.p).magnitude; newNode.cl = climbing; root.nodes.Add(newNode); root.useCachedBranchData = false; root.useCachedLeafData = false; if (!root.isAlive) { SmoothGaussianAdhesion(root); } var randomNode = root.nodes[Random.Range(0, root.nodes.Count)]; if (TryGrowIvyBranch(graph, ivyProfile, root, randomNode)) { break; } } }
static bool GenerateMeshData(IvyGraph ivyGraph, IvyProfile ivyProfile, bool forceGeneration = false) { var p = ivyProfile; //branches foreach (var root in ivyGraph.roots) { var cache = IvyRoot.GetMeshCacheFor(root); if (root.useCachedBranchData && !forceGeneration) { combinedTriangleIndices.Clear(); cache.triangles.ForEach(localIndex => combinedTriangleIndices.Add(localIndex + verticesAll.Count)); trianglesAll.AddRange(combinedTriangleIndices); verticesAll.AddRange(cache.vertices); texCoordsAll.AddRange(cache.texCoords); continue; } root.useCachedBranchData = true; //process only roots with more than one node if (root.nodes.Count < 2) { continue; } cache.vertices.Clear(); cache.texCoords.Clear(); cache.triangles.Clear(); //branch diameter depends on number of parents AND branch taper float local_ivyBranchDiameter = 1.0f / Mathf.Lerp(1f, 1f + root.parents, ivyProfile.branchTaper); // smooth the line... which increases points a lot allPoints = root.nodes.Select(node => node.p).ToList(); var useThesePoints = allPoints; if (ivyProfile.branchSmooth > 1) { SmoothLineCatmullRomNonAlloc(allPoints, smoothPoints, ivyProfile.branchSmooth); useThesePoints = smoothPoints; } // generate simplified points for each root, to make it less wavy AND save tris if (!root.isAlive && ivyProfile.branchOptimize > 0f) { newPoints.Clear(); newPoints.AddRange(SimplificationHelpers.Simplify <Vector3>( useThesePoints, (vec1, vec2) => vec1 == vec2, (vec) => vec.x, (vec) => vec.y, (vec) => vec.z, ivyProfile.branchOptimize * ivyProfile.ivyStepDistance * 0.5f, false )); useThesePoints = newPoints; } // I'm not sure why there's this bug when we use Catmull Rom + line simplify, but let's do this hacky fix // if ( ivyProfile.branchSmooth > 1 && ivyProfile.branchOptimize > 0f ) { // useThesePoints.ForEach( delegate(Vector3 point) { // if ( float.IsInfinity(point.x) ) {point.x = 0f;} // if ( float.IsInfinity(point.y) ) {point.y = 0f;} // if ( float.IsInfinity(point.z) ) {point.z = 0f;} // } ); // } for (int n = 0; n < useThesePoints.Count; n++) { if (verticesAll.Count >= 65531) { Debug.LogWarning("Hedera: ending branch generation early, reached ~65536 vertex limit on mesh " + ivyGraph.seedPos + "... but this could technically be solved in Unity 2017.3+ or later with 32-bit index formats for meshes? The exercise is left to the reader."); break; } cache.meshSegments = n + 1; //weight depending on ratio of node length to total length float taper = 1f * n / useThesePoints.Count; taper = Mathf.Lerp(1f, (1f - taper) * taper, ivyProfile.branchTaper); //create trihedral vertices... TODO: let user specify how many sides? Vector3 up = Vector3.down; Vector3 basis = Vector3.Normalize(n < useThesePoints.Count - 1 ? useThesePoints[n + 1] - useThesePoints[n] : -(useThesePoints[n] - useThesePoints[n - 1])); // Debug.DrawLine( newPoints[node+1] + ivyGraph.seedPos, newPoints[node] + ivyGraph.seedPos, Color.cyan, 5f, false); int edges = 3; // TODO: finish this, make it configurable float texV = (n % 2 == 0 ? 1f : 0.0f); // vertical UV tiling for (int b = 0; b < edges; b++) { // generate vertices if (b == 0) { branchVertBasis[b] = Vector3.Cross(up, basis).normalized *Mathf.Max(0.001f, local_ivyBranchDiameter * p.ivyBranchSize * taper) + useThesePoints[n]; } else { branchVertBasis[b] = RotateAroundAxis(branchVertBasis[0], useThesePoints[n], basis, 6.283f * b / edges); } cache.vertices.Add(branchVertBasis[b]); // generate UVs cache.texCoords.Add(new Vector2(1f * b / (edges - 1), texV)); // add triangles // AddTriangle(root, 4, 1, 5); // AddTriangle(root, 5, 1, 2); // TODO: finish this } if (n == 0) // start cap { if (taper > 0f) { AddTriangle(cache, 1, 2, 3); } continue; } AddTriangle(cache, 4, 1, 5); AddTriangle(cache, 5, 1, 2); AddTriangle(cache, 5, 2, 6); AddTriangle(cache, 6, 2, 3); AddTriangle(cache, 6, 3, 1); AddTriangle(cache, 6, 1, 4); if (n == useThesePoints.Count - 1 && taper > 0f) // end cap { AddTriangle(cache, 3, 2, 1); } } combinedTriangleIndices.Clear(); cache.triangles.ForEach(localIndex => combinedTriangleIndices.Add(localIndex + verticesAll.Count)); trianglesAll.AddRange(combinedTriangleIndices); verticesAll.AddRange(cache.vertices); texCoordsAll.AddRange(cache.texCoords); } if (ivyProfile.ivyLeafSize <= 0.001f || ivyProfile.leafProbability <= 0.001f) { return(true); } //create leafs allLeafPoints.Clear(); foreach (var root in ivyGraph.roots) { // don't bother on small roots if (root.nodes.Count <= 2) { root.useCachedLeafData = false; continue; } var cache = IvyRoot.GetMeshCacheFor(root); // use cached mesh data for leaves only if (a) we're supposed to, and (b) if not using vertex colors OR vertex colors seem valid if (root.useCachedLeafData && !forceGeneration && (!ivyProfile.useVertexColors || cache.leafVertices.Count == cache.leafVertexColors.Count)) { combinedTriangleIndices.Clear(); cache.leafTriangles.ForEach(index => combinedTriangleIndices.Add(index + leafVerticesAll.Count)); leafTrianglesAll.AddRange(combinedTriangleIndices); allLeafPoints.AddRange(cache.leafPoints); leafVerticesAll.AddRange(cache.leafVertices); leafUVsAll.AddRange(cache.leafUVs); if (ivyProfile.useVertexColors) { leafColorsAll.AddRange(cache.leafVertexColors); } continue; } root.useCachedLeafData = true; cache.leafPoints.Clear(); cache.leafVertices.Clear(); cache.leafUVs.Clear(); cache.leafTriangles.Clear(); cache.leafVertexColors.Clear(); // simple multiplier, just to make it a more dense for (int i = 0; i < 1; ++i) { var leafPositions = GetAllSamplePosAlongRoot(root, p.ivyLeafSize); // for(int n=0; n<root.nodes.Count; n++) foreach (var kvp in leafPositions) { if (leafVerticesAll.Count >= 65530) { Debug.LogWarning("Hedera: ending leaf generation early, reached ~65536 vertex limit on mesh " + ivyGraph.seedPos + "... but this could technically be solved in Unity 2017.3+ or later with 32-bit index formats for meshes? The exercise is left to the reader."); break; } int n = kvp.Value; Vector3 newLeafPos = kvp.Key; var node = root.nodes[n]; // // do not generate a leaf on the first few nodes // if ( n <= 1 ) { // || n >= root.nodes.Count // continue; // } // probability of leaves on the ground is increased float groundedness = Vector3.Dot(Vector3.down, node.c.normalized); if (groundedness < -0.02f) { groundedness -= 0.1f; groundedness *= 3f; } else { groundedness = (groundedness - 0.25f) * 0.5f; } groundedness *= ivyProfile.leafSunlightBonus * p.leafProbability; // don't spawn a leaf on top of another leaf bool badLeafPos = false; float leafSqrSize = p.ivyLeafSize * p.ivyLeafSize * Mathf.Clamp(1f - p.leafProbability - groundedness, 0.01f, 2f); for (int f = 0; f < allLeafPoints.Count; f++) { if (Vector3.SqrMagnitude(allLeafPoints[f] - newLeafPos) < leafSqrSize) { badLeafPos = true; break; } } if (badLeafPos) { continue; } IvyNode previousNode = root.nodes[Mathf.Max(0, n - 1)]; float randomSpreadHack = 0.25f; if (n <= 1 || n == root.nodes.Count - 1) { randomSpreadHack = 0f; } // randomize leaf probability // guarantee a leaf on the first or last node if ((Random.value + groundedness > 1f - p.leafProbability) || randomSpreadHack == 0f) { cache.leafPoints.Add(node.p); allLeafPoints.Add(node.p); //center of leaf quad Vector3 up = (newLeafPos - previousNode.p).normalized; Vector3 right = Vector3.Cross(up, node.c); Vector3 center = newLeafPos - node.c.normalized * 0.05f + (up * Random.Range(-1f, 1f) + right * Random.Range(-1f, 1f)) * randomSpreadHack * p.ivyLeafSize; //size of leaf float sizeWeight = 1.5f - (Mathf.Abs(Mathf.Cos(2.0f * Mathf.PI)) * 0.5f + 0.5f); float leafSize = p.ivyLeafSize * sizeWeight + Random.Range(-p.ivyLeafSize, p.ivyLeafSize) * 0.1f + (p.ivyLeafSize * groundedness); leafSize = Mathf.Max(0.01f, leafSize); Quaternion facing = node.c.sqrMagnitude < 0.001f ? Quaternion.identity : Quaternion.LookRotation(Vector3.Lerp(-node.c, Vector3.up, Mathf.Clamp01(0.68f - Mathf.Abs(groundedness)) * ivyProfile.leafSunlightBonus), Random.onUnitSphere); AddLeafVertex(cache, center, new Vector3(-1f, 1f, 0f), leafSize, facing); AddLeafVertex(cache, center, new Vector3(1f, 1f, 0f), leafSize, facing); AddLeafVertex(cache, center, new Vector3(-1f, -1f, 0f), leafSize, facing); AddLeafVertex(cache, center, new Vector3(1f, -1f, 0f), leafSize, facing); cache.leafUVs.Add(new Vector2(1.0f, 1.0f)); cache.leafUVs.Add(new Vector2(0.0f, 1.0f)); cache.leafUVs.Add(new Vector2(1.0f, 0.0f)); cache.leafUVs.Add(new Vector2(0.0f, 0.0f)); if (ivyProfile.useVertexColors) { var randomColor = ivyProfile.leafVertexColors.Evaluate(Random.value); cache.leafVertexColors.Add(randomColor); cache.leafVertexColors.Add(randomColor); cache.leafVertexColors.Add(randomColor); cache.leafVertexColors.Add(randomColor); } // calculate normal of the leaf tri, and make it face outwards // var normal = GetNormal( // ivyGraph.leafVertices[ivyGraph.leafVertices.Count - 2], // ivyGraph.leafVertices[ivyGraph.leafVertices.Count - 4], // ivyGraph.leafVertices[ivyGraph.leafVertices.Count - 3] // ); // if ( Vector3.Dot( normal, node.adhesionVector) < 0f) { // AddLeafTriangle(ivyGraph, 2, 4, 3); // AddLeafTriangle(ivyGraph, 3, 1, 2); // } else { AddLeafTriangle(cache, 1, 3, 4); AddLeafTriangle(cache, 4, 2, 1); // } } } combinedTriangleIndices.Clear(); cache.leafTriangles.ForEach(index => combinedTriangleIndices.Add(index + leafVerticesAll.Count)); leafTrianglesAll.AddRange(combinedTriangleIndices); leafVerticesAll.AddRange(cache.leafVertices); leafUVsAll.AddRange(cache.leafUVs); if (ivyProfile.useVertexColors) { leafColorsAll.AddRange(cache.leafVertexColors); } } } return(true); }