com.warwlock.mtree 1.0.2

package/Runtime/Splines.cs

@@ -0,0 +1,379 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace Mtree
+{
+    public class Splines
+    {
+        Stack<Queue<TreePoint>> splines;
+        public Queue<Vector3> verts;
+        public Queue<Vector3> normals;
+        public Queue<int> triangles;
+        public Queue<Vector2> uvs;
+        public Queue<Color> colors;
+
+
+
+        public Splines(Stack<Queue<TreePoint>> points)
+        {
+            splines = points;
+            verts = new Queue<Vector3>();
+            uvs = new Queue<Vector2>();
+            normals = new Queue<Vector3>();
+            triangles = new Queue<int>();
+            colors = new Queue<Color>();
+        }
+
+        public void GenerateMeshData(float resolutionMultiplier, int minResolution, AnimationCurve rootShape, float radiusMultiplier
+                                    , float rootRadius, float rootInnerRadius, float rootHeight, float RootResolutionMultiplier, int flaresNumber, float displacmentStrength
+                                    , float displacmentSize, float spinAmount,float VColBarkModifier)
+        {
+            Queue<int> trianglesWithBadNormals = new Queue<int>(); // Triangles whose verts have been displaced, needing their normals to be recalculated
+            Queue<Vector2Int> duplicatedVertexIndexes = new Queue<Vector2Int>(); // Used when recalculating normals to avoid shading seams
+            int[] trunkTriangles = null;
+            Vector3[] trunkVertices = null;
+            Queue<BarycentricCoordinates> projectedVertices = new Queue<BarycentricCoordinates>();
+            bool isTrunk = true;
+            while (splines.Count > 0) // Each spline is an entire branch
+            {
+                SimplexNoiseGenerator noiseGenerator = new SimplexNoiseGenerator(new int[] { 0x16, 0x38, 0x32, 0x2c, 0x0d, 0x13, 0x07, 0x2a });
+                Queue<TreePoint> spline = splines.Pop();
+                int lastResolution = -1;
+                float uv_height = 0f;
+                while (spline.Count > 0) // drawing each node inside the branch
+                {
+                    TreePoint point = spline.Dequeue();
+                    point.radius = Mathf.Max(point.radius, 0.001f);
+                    int resolution = getResolution(point, minResolution, rootRadius, rootHeight, resolutionMultiplier);
+
+                    Vector3[] newVerts;
+
+                    int n = verts.Count;
+
+                    if (lastResolution == -1 && point.parentRadius != 0 && point.type == NodeType.FromTrunk)
+                    {
+                        newVerts = AddCircleWrapped(point.position, point.direction, point.radius, resolution, point.parentRadius, point.parentDirection, displacmentStrength);
+                        ProjectBranchesOnTrunk(trunkTriangles, trunkVertices, ref newVerts, projectedVertices, n);
+                    }
+                    else
+                    {
+                        newVerts = AddCircle(point.position, point.direction, point.radius, resolution, uv_height * spinAmount * point.radius);
+                    }
+                    duplicatedVertexIndexes.Enqueue(new Vector2Int(n, n + resolution - 1));
+                    BridgeLoops(newVerts, point, lastResolution, uv_height, n, getFillingGapRate(lastResolution, resolution), flaresNumber, rootRadius, rootInnerRadius, rootHeight, radiusMultiplier,
+                                rootShape, noiseGenerator, displacmentSize, displacmentStrength, trianglesWithBadNormals,VColBarkModifier);
+                    if (spline.Count > 0)
+                    {
+                        float rad = point.radius;
+                        if (point.type == NodeType.Flare)
+                            rad += rootRadius * rootShape.Evaluate(point.position.y / rootHeight) * radiusMultiplier;
+                        uv_height += (point.position - spline.Peek().position).magnitude / rad;
+                    }
+
+                    lastResolution = resolution;
+                }
+                if (isTrunk)
+                {
+                    trunkTriangles = triangles.ToArray();
+                    trunkVertices = verts.ToArray();
+                    isTrunk = false;
+                }
+            }
+            RecalculateNormals(duplicatedVertexIndexes, trianglesWithBadNormals, projectedVertices);
+        }
+
+        void BridgeLoops(Vector3[] loop, TreePoint point, int lastResolution, float uvHeight, int n, int fillingGapRate, int flaresNumber,
+                         float rootRadius, float rootInnerRadius, float rootHeight, float radiusMultiplier, AnimationCurve rootShape, SimplexNoiseGenerator noiseGenerator,
+                         float displacementSize, float displacementStrength, Queue<int> trianglesWithBadNormals, float VColBarkModifier)
+        {
+            int resolution = loop.Length;
+            int gaps = lastResolution - resolution; //difference between the two loops
+            for (int i = 0; i < resolution; i++)
+            {
+                Vector3 vert = loop[i];
+                Vector3 normal = (vert - point.position).normalized;
+
+                Vector3 nrm = (vert - point.position).normalized;
+                if (lastResolution == -1)
+                {
+                    Vector3 orthoDir = Vector3.ProjectOnPlane(point.direction, point.parentDirection).normalized;
+                    Vector3 center = (loop[0] + loop[resolution / 2]) / 2 - orthoDir * point.parentRadius;
+                    Vector3 pos = Vector3.Project(vert - center, point.parentDirection) + center;
+                    nrm = (vert - pos).normalized;
+                }
+                bool badNormals = false;
+                if (point.type == NodeType.Trunk || point.type == NodeType.Flare) //Trunk displacement
+                {
+                    vert += noiseGenerator.noiseGradient(vert * displacementSize / radiusMultiplier, flat: true) / 5 * point.radius * displacementStrength;
+                    badNormals = true;
+                }
+
+                if (point.type == NodeType.Flare) // root flares displacement
+                {
+                    float angle = i * 1f / (resolution - 1) * 2 * Mathf.PI;
+                    float displacement = Mathf.Lerp(Mathf.Abs(Mathf.Sin(angle * flaresNumber / 2f)), 1, rootInnerRadius) * rootRadius * rootShape.Evaluate(point.position.y / rootHeight) * radiusMultiplier;
+                    vert += normal * displacement;
+                }
+
+                verts.Enqueue(vert);
+                normals.Enqueue(nrm);
+                uvs.Enqueue(new Vector2(i * 1f / (resolution - 1), uvHeight / 3.2f) * -1);
+                if (i > 0 && lastResolution > 0)
+                {
+                    if (badNormals)
+                    {
+                        trianglesWithBadNormals.Enqueue(triangles.Count);
+                        trianglesWithBadNormals.Enqueue(triangles.Count + 3);
+                    }
+                    AddTriangle(n - lastResolution + i - 1, n + i - 1, n - lastResolution + i);
+                    AddTriangle(n + i - 1, n + i, n - lastResolution + i);
+                    if (i % fillingGapRate == 0 && gaps > 0) // filling a gap
+                    {
+                        if (badNormals)
+                            trianglesWithBadNormals.Enqueue(triangles.Count);
+                        AddTriangle(n - lastResolution + i, n + i, n - lastResolution + i + 1);
+                        gaps--;
+                        lastResolution--;
+                    }
+                }
+                Color col = new Color((point.distanceFromOrigin / 10) * VColBarkModifier, 0, 0);
+                colors.Enqueue(col);
+            }
+            if (gaps > 0) // Fill eventual remaining gap 
+            {
+                for (int i = 0; i < gaps; i++)
+                {
+                    AddTriangle(n - lastResolution + resolution + i - 1, n + resolution - 1, n - lastResolution + resolution + i);
+                }
+            }
+
+        }
+
+        int getFillingGapRate(int lastResolution, int resolution)
+        {
+            int gaps = lastResolution - resolution; //difference between the two loops
+            int fillingGapRate = int.MaxValue; //rate at which an additional triangle must be created
+            if (gaps > resolution)
+                resolution = gaps; // increase resolution when there are too many gaps to fill
+            if (gaps > 0)
+                fillingGapRate = resolution / gaps;
+
+            return fillingGapRate;
+        }
+
+        int getResolution(TreePoint point, int minResolution, float rootRadius, float rootHeight, float resolutionMultiplier)
+        {
+            int resolution = (int)((point.radius) * resolutionMultiplier * 7);
+
+            if (point.type == NodeType.Flare)
+                resolution += (int)(rootRadius * (Mathf.Pow(1 - Mathf.Max(0, point.position.y / rootHeight), 2)) * resolutionMultiplier * 3);
+
+            if (resolution < minResolution)
+                resolution = minResolution;
+            resolution++;
+            return resolution;
+        }
+
+        public void RecalculateNormals(Queue<Vector2Int> duplicatedVerts, Queue<int> selectedTriangles, Queue<BarycentricCoordinates> projectedVertices)
+        {
+            Vector3[] newNormals = normals.ToArray();
+            HashSet<int> overidenIndexes = new HashSet<int>();
+            Vector3[] Verts = verts.ToArray();
+            int[] Tris = triangles.ToArray();
+            int n = Tris.Length;
+            foreach (int i in selectedTriangles)
+            {
+                int a = Tris[i];
+                int b = Tris[i + 1];
+                int c = Tris[i + 2];
+
+                if (!overidenIndexes.Contains(a))
+                {
+                    newNormals[a] = Vector3.zero;
+                    overidenIndexes.Add(a);
+                }
+                if (!overidenIndexes.Contains(b))
+                {
+                    newNormals[b] = Vector3.zero;
+                    overidenIndexes.Add(b);
+                }
+                if (!overidenIndexes.Contains(c))
+                {
+                    newNormals[c] = Vector3.zero;
+                    overidenIndexes.Add(c);
+                }
+
+                Vector3 nrm = Vector3.Cross(Verts[b] - Verts[a], Verts[c] - Verts[a]);
+
+                newNormals[a] += nrm;
+                newNormals[b] += nrm;
+                newNormals[c] += nrm;
+            }
+
+            foreach (int i in overidenIndexes)
+            {
+                newNormals[i].Normalize();
+            }
+
+            foreach (Vector2Int indexes in duplicatedVerts)
+            {
+                int x = indexes.x;
+                int y = indexes.y;
+                Vector3 nrm = (newNormals[x] + newNormals[y]) / 2;
+                newNormals[x] = newNormals[y] = nrm;
+            }
+
+
+            foreach (BarycentricCoordinates coords in projectedVertices)
+            {
+                newNormals[coords.index] = (newNormals[coords.i1] * coords.w1 + newNormals[coords.i2] * coords.w2 + newNormals[coords.i3] * coords.w3);
+                //newNormals[coords.index] = Vector3.up;  
+            }
+
+            normals = new Queue<Vector3>(newNormals);
+        }
+
+        public static Vector3[] AddCircle(Vector3 position, Vector3 direction, float radius, int resolution, float spinAngle)
+        {
+            Vector3[] verts = new Vector3[resolution];
+            Quaternion rotation = Quaternion.FromToRotation(Vector3.up, direction);
+            for (int i = 0; i < resolution; i++)
+            {
+                float angle = Mathf.PI * 2 * ((float)i / (resolution - 1)) + spinAngle;
+                Vector3 vert = new Vector3(Mathf.Cos(angle) * radius, 0, Mathf.Sin(angle) * radius);
+                verts[i] = rotation * vert + position;
+            }
+            return verts;
+        }
+
+        public static Vector3[] AddCircleWrapped(Vector3 position, Vector3 direction, float radius, int resolution, float parentRadius, Vector3 parentDirection, float displcementStrength)
+        {
+            Vector3[] verts = new Vector3[resolution];
+            Vector3 orthoDir = Vector3.ProjectOnPlane(direction, parentDirection).normalized;
+            Quaternion rotation = Quaternion.FromToRotation(Vector3.up, orthoDir);
+            Vector3 tangent = Vector3.Cross(parentDirection, orthoDir);
+            float scale = Mathf.Sqrt(Mathf.Pow(Mathf.Tan(90 - Vector3.Angle(direction, parentDirection) * Mathf.PI / 180), 2) + 1);
+            scale = Mathf.Min(scale, 4f) / 4;
+            Matrix4x4 scaleMat = Matrix4x4.identity;
+            scaleMat[0, 0] += parentDirection.x * scale;
+            scaleMat[1, 1] += parentDirection.y * scale;
+            scaleMat[2, 2] += parentDirection.z * scale;
+            for (int i = 0; i < resolution; i++)
+            {
+                float angle = Mathf.PI * 2 * ((float)i / (resolution - 1));
+                Vector3 vert = new Vector3(Mathf.Cos(angle) * radius, 0, Mathf.Sin(angle) * radius);
+                vert = (rotation * vert);
+                float wrap = Mathf.Sin(Mathf.Acos(Mathf.Clamp01(Mathf.Abs(Vector3.Dot(vert, tangent)) / parentRadius))) * parentRadius;
+                vert = scaleMat.MultiplyPoint(vert);
+                vert += orthoDir * wrap;
+                vert += position + parentDirection * Vector3.Dot(direction, parentDirection) * parentRadius;
+                verts[i] = vert;
+            }
+            return verts;
+        }
+
+        public void AddTriangle(int a, int b, int c)
+        {
+            triangles.Enqueue(a);
+            triangles.Enqueue(b);
+            triangles.Enqueue(c);
+        }
+
+        public void ProjectBranchesOnTrunk(int[] trunkTriangles, Vector3[] trunkVertices, ref Vector3[] vertices, Queue<BarycentricCoordinates> projectedVertices, int verticesCount)
+        {
+            Vector3[] centers = new Vector3[trunkTriangles.Length / 3];
+            for (int i = 0; i < centers.Length; i++)
+                centers[i] = (trunkVertices[trunkTriangles[i * 3]] + trunkVertices[trunkTriangles[i * 3 + 1]] + trunkVertices[trunkTriangles[i * 3 + 2]]) / 3;
+
+            for (int i = 0; i < vertices.Length; i++)
+            {
+                Vector3 vert = vertices[i];
+                int closestTriangle = 0;
+                float minDist = Mathf.Infinity;
+                for (int j = 0; j < centers.Length; j++)
+                {
+                    float dist = Vector3.SqrMagnitude(centers[j] - vert);
+                    if (dist < minDist)
+                    {
+                        minDist = dist;
+                        closestTriangle = j * 3;
+                    }
+                }
+
+                Vector3 projectedVert = ClosestPointOnTriangle(trunkVertices[trunkTriangles[closestTriangle]], trunkVertices[trunkTriangles[closestTriangle + 1]], trunkVertices[trunkTriangles[closestTriangle + 2]], vertices[i]);
+                Vector3 coordinates = Barycentric(projectedVert, trunkVertices[trunkTriangles[closestTriangle]], trunkVertices[trunkTriangles[closestTriangle + 1]], trunkVertices[trunkTriangles[closestTriangle + 2]]);
+                projectedVertices.Enqueue(new BarycentricCoordinates(verticesCount + i, trunkTriangles[closestTriangle], trunkTriangles[closestTriangle], trunkTriangles[closestTriangle], coordinates));
+                vertices[i] = projectedVert;
+            }
+            //vertices[i] = centers[closestTriangle / 3];
+        }
+
+        public Vector3 ClosestPointOnTriangle(Vector3 v1, Vector3 v2, Vector3 v3, Vector3 point)
+        {
+            Vector3 normal = Vector3.Cross(v1 - v2, v1 - v3);
+            return Vector3.ProjectOnPlane(point - v1, normal) + v1;
+        }
+
+        private Vector3 Barycentric(Vector3 p, Vector3 a, Vector3 b, Vector3 c)
+        {
+            Vector3 v0 = b - a;
+            Vector3 v1 = c - a;
+            Vector3 v2 = p - a;
+            float d00 = Vector3.Dot(v0, v0);
+            float d01 = Vector3.Dot(v0, v1);
+            float d11 = Vector3.Dot(v1, v1);
+            float d20 = Vector3.Dot(v2, v0);
+            float d21 = Vector3.Dot(v2, v1);
+            float denom = d00 * d11 - d01 * d01;
+
+            Vector3 coordinates = Vector3.zero;
+            coordinates.y = (d11 * d20 - d01 * d21) / denom;
+            coordinates.z = (d00 * d21 - d01 * d20) / denom;
+            coordinates.x = 1.0f - coordinates.y - coordinates.z;
+
+            return coordinates;
+        }
+
+    }
+
+    public struct Vector2Int
+    {
+        public int x;
+        public int y;
+
+        public Vector2Int(int x, int y)
+        {
+            this.x = x;
+            this.y = y;
+        }
+
+    }
+
+    public struct BarycentricCoordinates
+    {
+        public int index; // the index of the vertex/normal that is described by the coordinates
+
+        public int i1; // the index of the first vertex of the triangle
+        public int i2; // the index of the second vertex of the triangle
+        public int i3; // the index of the third vertex of the triangle
+
+        public float w1; // the weight of the first vertex
+        public float w2; // the weight of the second vertex
+        public float w3; // the weight of the third vertex
+
+        public BarycentricCoordinates(int index, int i1, int i2, int i3, Vector3 coordinates)
+        {
+            this.index = index;
+
+            this.i1 = i1;
+            this.i2 = i2;
+            this.i3 = i3;
+
+            w1 = coordinates.x;
+            w2 = coordinates.y;
+            w3 = coordinates.z;
+        }
+    }
+}

package/Runtime/Splines.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2538cdcc21e4924499ea8a7119b19c3d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/TreeBilboard.cs

@@ -0,0 +1,290 @@
+#if UNITY_EDITOR
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+using System.Linq;
+
+namespace Mtree
+{
+    class Billboard
+    {
+        private Camera cam;
+        private GameObject target;
+        private int width = 512;
+        private int height = 512;
+        private Texture2D[] sides;
+        private Rect[] rects;
+        private float ZBuffer = 0.03f;
+        private float TopCardPosition = 0.5f;
+        private bool hasTopCard,isSingleSided;
+        int cards = 2;
+        public Billboard(Camera cam, GameObject target, int width, int height, float TopCardPosition, bool hasTopCard, bool isSingleSided)
+        {
+            this.cam = cam;
+            this.target = target;
+            this.width = width;
+            this.height = height;
+            this.TopCardPosition = TopCardPosition;
+            this.isSingleSided = isSingleSided;
+
+            if (isSingleSided)
+                cards += 2;
+            if (hasTopCard && !isSingleSided)
+                cards += 1;
+            if (hasTopCard && isSingleSided)
+                cards += 2;
+
+            sides = new Texture2D[cards];
+        }
+
+
+
+        public void SetupCamera()
+        {
+            float rw = width;
+            rw /= Screen.width;
+            float rh = height;
+            rh /= Screen.height;
+
+            Bounds bb = target.GetComponent<Renderer>().bounds;
+
+            cam.transform.position = bb.center;
+            cam.nearClipPlane = -bb.extents.x;
+            cam.farClipPlane = bb.extents.x;
+            cam.orthographicSize = bb.extents.y;
+            cam.aspect = bb.extents.x / bb.extents.y * 2;
+
+            if (cam.aspect <= 1)
+                width = (int)(height * cam.aspect);
+            else
+                height = (int)(width / cam.aspect);
+
+        }
+
+        public void Render(string path)
+        {
+            Bounds bb = target.GetComponent<Renderer>().bounds;
+            int layer = target.layer;
+            target.layer = 31;
+            cam.cullingMask = 1 << 31;
+            var originalPos = cam.transform.position;
+            cam.transform.position = new Vector3(target.transform.position.x, bb.center.y, target.transform.position.z);
+            for (int i = 0; i < cards; i++)
+            {
+                RenderTexture currentRT = RenderTexture.active;
+                RenderTexture camText = new RenderTexture(width, height, 16);
+
+                cam.targetTexture = camText;
+                RenderTexture.active = cam.targetTexture;
+                cam.Render();
+                Texture2D image = new Texture2D(cam.targetTexture.width, cam.targetTexture.height);
+                image.ReadPixels(new Rect(0, 0, cam.targetTexture.width, cam.targetTexture.height), 0, 0);
+
+                if (i == 5)
+                {
+                    Color32[] originalPixels = image.GetPixels32().Reverse().ToArray();
+                    var flippedPixels =
+                        Enumerable.Range(0, image.width * image.height)
+                        .Select(index =>
+                        {
+                            int x = index % image.width;
+                            int y = index / image.width;
+                            x = image.width - 1 - x;
+                            return originalPixels[y * image.width + x];
+                        }
+                        );
+                    image.SetPixels32(flippedPixels.ToArray());
+                }
+                image.Apply();
+                RenderTexture.active = currentRT;
+                sides[i] = image;
+
+                if (isSingleSided)
+                {
+                    if (i < 3)
+                        cam.transform.Rotate(Vector3.up * 90);
+                    if (i == 3)
+                    {
+                        cam.ResetAspect();
+                        cam.aspect = 1;
+                        cam.orthographicSize = Mathf.Max(bb.extents.x, bb.extents.z) * 2;
+
+                        cam.transform.position = originalPos;
+                        var t = cam.transform.position;
+                        cam.transform.position = new Vector3(t.x, bb.extents.y * 2, t.z);
+                        cam.transform.Rotate(Vector3.right * 90);
+                        cam.farClipPlane = bb.extents.y * 3;
+                        cam.nearClipPlane = -bb.extents.y * 3;
+                    }
+                   
+                }
+                if (!isSingleSided)
+                {
+                    if (i == 0)
+                        cam.transform.Rotate(Vector3.up * 90);
+                    if (i == 1)
+                    {
+                        cam.ResetAspect();
+                        cam.aspect = 1;
+                        cam.orthographicSize = Mathf.Max(bb.extents.x, bb.extents.z) * 2;
+
+                        cam.transform.position = originalPos;
+                        cam.transform.Rotate(Vector3.up * 180);
+                        var t = cam.transform.position;
+                        cam.transform.position = new Vector3(t.x, bb.extents.y * 2, t.z);
+                        cam.transform.Rotate(Vector3.right * 90);
+                        cam.farClipPlane = bb.extents.y * 3;
+                        cam.nearClipPlane = -bb.extents.y * 3;
+
+                    }
+                }
+
+            }
+
+            Texture2D atlas = new Texture2D(width, height);
+            rects = atlas.PackTextures(sides, 0, Mathf.Min(height, width) * cards);
+            Utils.DilateTexture(atlas, 100);
+            byte[] bytes = atlas.EncodeToPNG();
+            System.IO.File.WriteAllBytes(path, bytes);
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+            target.layer = layer;
+        }
+
+        public Mesh CreateMesh()
+        {
+            Vector3[] verts = new Vector3[cards * 4];
+            Vector3[] normals = new Vector3[cards * 4];
+            Vector2[] uvs = new Vector2[cards * 4];
+            int[] triangles = new int[cards * 6];
+
+            Bounds bb = target.GetComponent<MeshRenderer>().bounds;
+            float maxTC = Mathf.Max(bb.extents.x, bb.extents.z);
+            for (int i = 0; i < cards; i++)
+            {
+                var count = i;
+
+                if (i == 4 || i == 2 && !isSingleSided)
+                    count = 0;
+
+                float angle = 90f * count + 180;
+                Vector3 x = Quaternion.Euler(0f, angle, 0f) * Vector3.left * bb.extents.x * 2;
+                Vector3 normal = Quaternion.Euler(0f, angle, 0f) * Vector3.back;
+                Vector3 y = Vector3.up * bb.extents.y * 2;
+
+                Vector3 v0 = x;
+                Vector3 v1 = x + y;
+                Vector3 v2 = y - x;
+                Vector3 v3 = -x;
+
+
+                if (i == 0 && isSingleSided)
+                {
+
+                    v0.z += ZBuffer;
+                    v1.z += ZBuffer;
+                    v2.z += ZBuffer;
+                    v3.z += ZBuffer;
+                }
+                if (i == 1 && isSingleSided)
+                {
+
+                    v0.x += ZBuffer;
+                    v1.x += ZBuffer;
+                    v2.x += ZBuffer;
+                    v3.x += ZBuffer;
+                }
+                
+                if (i == 4 || !isSingleSided && i == 2)
+                {
+                    float height = Mathf.Lerp(0, bb.extents.y * 2, TopCardPosition);
+                    float bbX = bb.extents.x * 2 - (rects[i].width / 2);
+                    float bbZ = bb.extents.z * 2 - (rects[i].height / 2);
+                    
+                    v0 = new Vector3(-bbX, height, bbZ);
+                    v1 = new Vector3(bbX, height, bbZ);
+                    v2 = new Vector3(bbX, height, -bbZ);
+                    v3 = new Vector3(-bbX, height, -bbZ);
+
+                }
+                if (i == 5)
+                {
+                    float height = Mathf.Lerp(0, bb.extents.y * 2, TopCardPosition) - ZBuffer;
+                    float bbX = bb.extents.x * 2 - (rects[i-1].width / 2);
+                    float bbZ = bb.extents.z * 2 - (rects[i-1].height / 2);
+
+                    v0 = new Vector3(bbX, height, bbZ);
+                    v1 = new Vector3(-bbX, height, bbZ);
+                    v2 = new Vector3(-bbX, height, -bbZ);
+                    v3 = new Vector3(bbX, height, -bbZ);
+                }
+
+
+                verts[4 * i + 0] = v0;
+                verts[4 * i + 1] = v1;
+                verts[4 * i + 2] = v2;
+                verts[4 * i + 3] = v3;
+
+                x.Normalize();
+                float normalFacing = 50f;
+                Vector3 n0 = (x + normalFacing * normal).normalized;
+                Vector3 n1 = (x + normalFacing * normal).normalized;
+                Vector3 n2 = (-x + normalFacing * normal).normalized;
+                Vector3 n3 = (-x + normalFacing * normal).normalized;
+
+
+                normals[4 * i] = n0;
+                normals[4 * i + 1] = n1;
+                normals[4 * i + 2] = n2;
+                normals[4 * i + 3] = n3;
+
+                triangles[6 * i] = 4 * i;
+                triangles[6 * i + 1] = 4 * i + 1;
+                triangles[6 * i + 2] = 4 * i + 2;
+                triangles[6 * i + 3] = 4 * i + 2;
+                triangles[6 * i + 4] = 4 * i + 3;
+                triangles[6 * i + 5] = 4 * i;
+
+                Vector2 c = rects[i].center;
+                Vector2 u = new Vector2();
+                Vector2 v = new Vector2();
+
+                u = new Vector2(rects[i].max.x - c.x, 0f);
+                v = new Vector2(0f, rects[i].max.y - c.y);
+
+
+                uvs[4 * i] = c + u - v;
+                uvs[4 * i + 1] = c + u + v;
+                uvs[4 * i + 2] = c - u + v;
+                uvs[4 * i + 3] = c - u - v;
+
+            }
+            Mesh mesh = new Mesh
+            {
+                vertices = verts,
+                triangles = triangles,
+                uv = uvs,
+                normals = normals
+            };
+            return mesh;
+        }
+
+        public Material CreateMaterial(Texture tex, bool usingHDRP)
+        {
+            Bounds bb = target.GetComponent<MeshRenderer>().bounds;
+            var pipeline = GraphicsSettings.defaultRenderPipeline;
+            Shader shader = Utils.GetBillboardShader();
+            if (usingHDRP)
+                shader = Shader.Find("Mtree/SRP/Billboard HDRP");
+            Material mat = new Material(shader);
+            mat.mainTexture = tex;
+            mat.SetFloat("_AlphaClip", 1);
+            return mat;
+        }
+
+    }
+
+}
+#endif

package/Runtime/TreeBilboard.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8a7906053e763c64aa9df9bb3cf10070
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: