public Product CreateProduct(StoreObjectReference container, Box.PackagedBud bud)
{ // Create a container and put packaged bud into it
GameObject newContainer = Instantiate(container.gameObject_);
newContainer.transform.position = bud.parentBox.transform.position;
ProductGO productGO = newContainer.GetComponent <ProductGO>();
if (container.proType == StoreObjectReference.productType.jar)
{
StorageJar storageJar = new StorageJar(container, newContainer);
storageJar.uniqueID = Dispensary.GetUniqueProductID();
productGO.product = storageJar;
float incrementValue = 1;
List <Bud> newBuds = new List <Bud>();
while (bud.weight > 0)
{
if (bud.weight - 1 < 0)
{
incrementValue = bud.weight;
}
GameObject budGO = new GameObject(bud.strain.name + " Nug");
budGO.transform.SetParent(newContainer.transform);
budGO.transform.localPosition = Vector3.zero;
Bud newBud = budGO.AddComponent <Bud>();
newBud.strain = bud.strain;
newBud.weight = incrementValue;
newBuds.Add(newBud);
bud.weight -= incrementValue;
}
print("Adding buds");
storageJar.AddBud(newBuds);
return(storageJar);
}
return(null);
}
private void draw_internode(Internode internode, int coe)
{
Vector3 startPos = internode.start_node.position + this.transform.position;
Vector3 endPos = internode.end_node.position + this.transform.position;
Bud bud = internode.start_node.node_bud;
Vector3 T = bud.get_direction();
Vector3 N = Quaternion.Euler(0.0f, 0.0f, 90.0f) * T;
Vector3 B = Vector3.Cross(T, N);
int start_age = internode.start_node.node_bud.age;
int end_age = internode.end_node.node_bud.age;
Mesh my_mesh = Create_My_Mesh(T.normalized, N.normalized, B.normalized, startPos, endPos, start_age, end_age);
GameObject s = new GameObject("Textured Mesh");
s.transform.position = this.transform.position;
s.AddComponent <MeshFilter>();
s.AddComponent <MeshRenderer>();
s.GetComponent <MeshFilter>().mesh = my_mesh;
Renderer rend = s.GetComponent <Renderer>();
s.transform.parent = this.transform;
if (curveUpward == false)
{
rend.material.color = new Color(Random.value, 1.0f, 1.0f, 1.0f);
}
else if (curveUpward == true)
{
rend.material.color = new Color(1.0f, Random.value, 1.0f, 1.0f);
}
}
private void Awake()
{
_parent = GetComponentInParent <Bud>();
_renderer = GetComponent <SpriteRenderer>();
_playerInside = false;
_renderer.color = ColorOut;
}
private void evaluateState(ref Bud bud)
{
if (bud.v > 0)
{
bud.state = BudState.NEW_METAMER;
}
}
// Evalue l'énergie pour les éventuelles branches adjacentes (main et lateral) du bourgeon traité
private void evaluateEnergy(ref Node <Bud> N)
{
Bud bud = N.value;
Node <Bud> lateral = N.lateral;
Node <Bud> main = N.main;
bool hasLateral = (lateral != null);
bool hasMain = (main != null);
float Ql = 0f;
float Qm = 0f;
if (hasLateral)
{
Ql = lateral.value.Q;
}
if (hasMain)
{
Qm = main.value.Q;
}
float d = (lambda * Qm) + (1 - lambda) * Ql;
if (hasLateral)
{
float e = (bud.v * (1 - lambda) * Ql) / d;
lateral.value.setEnergy(e);
}
if (hasMain)
{
float e = (bud.v * lambda * Qm) / d;
main.value.setEnergy(e);
}
}
public void AddStartJar()
{
List <StoreObjectReference> containerObjects = db.GetProducts(StoreObjectReference.productType.container);
GameObject jar = Instantiate(containerObjects[1].gameObject_);
ProductGO productGO = jar.GetComponent <ProductGO>();
productGO.objectID = containerObjects[1].objectID;
StorageJar storageJar = new StorageJar(containerObjects[1], jar);
storageJar.uniqueID = Dispensary.GetUniqueProductID();
storageJar.objectID = containerObjects[1].objectID;
productGO.product = storageJar;
productGO.canHighlight = true;
jar.GetComponent <Jar>().product = storageJar;
List <Bud> toAdd = new List <Bud>();
Strain toUse = db.GetRandomStrain();
for (int i = 0; i < 28; i++)
{
GameObject bud = new GameObject("Bud");
Bud newBud = bud.AddComponent <Bud>();
newBud.strain = toUse;
newBud.weight = UnityEngine.Random.Range(.65f, 1.35f);
newBud.weight = Mathf.Round(newBud.weight * 100f) / 100f; // Round to 2 decimal places
jar.GetComponent <Jar>().AddBud(bud);
bud.transform.position = Vector3.zero;
toAdd.Add(newBud);
}
storageJar.AddBud(toAdd);
ShelfPosition jarPosition = dm.dispensary.Storage_cs[0].GetRandomStorageLocation(storageJar);
jar.transform.position = jarPosition.transform.position;
jar.transform.parent = jarPosition.transform;
jarPosition.shelf.parentShelf.AddProduct(storageJar);
}
public Node(Bud bud, Vector3 pos, bool curve, bool trop)
{
node_bud = bud;
position = pos;
bud_list.Add(bud);
curveUpward = curve;
tropical = trop;
}
void circleSampling(ref Node <Bud> node, bool lateralMode)
{
Bud currentBud = node.value;
Vector3 axis = Vector3.down;
if (!node.isRoot())
{
if (lateralMode && currentBud.lateralDir != null)
{
axis = currentBud.lateralDir;
}
else
{
Vector3 previousBudPos = node.parent.value.pos;
Vector3 currentBudPos = currentBud.pos;
axis = Vector3.Normalize(previousBudPos - currentBudPos);
}
}
Vector3 side = Quaternion.Euler(90, 0, 90) * axis;
Vector3 budPos = currentBud.pos;
float angle = 0f;
float stepAngle = 360f / (float)subdivision_qty;
Vector3 normale = side;
if (lateralMode)
{
currentBud.lateralVertices = new List <Vector3>();
currentBud.lateralNormales = new List <Vector3>();
}
else
{
currentBud.mainVertices = new List <Vector3>();
currentBud.mainNormales = new List <Vector3>();
}
for (int i = 0; i < subdivision_qty; i++)
{
angle += stepAngle;
normale = Quaternion.AngleAxis(stepAngle, axis) * normale;
Vector3 pt = budPos + normale * node.value.branchWidth;
if (lateralMode)
{
currentBud.lateralVertices.Add(pt);
currentBud.lateralNormales.Add(normale);
}
else
{
currentBud.mainVertices.Add(pt);
currentBud.mainNormales.Add(normale);
}
}
}
private void addMetamer(ref TreeGraph <Bud> skeleton, ref List <Node <Bud> > leaves, ref Node <Bud> currentNode)
{
Bud currentBud = currentNode.value;
float internodeLength = currentBud.l;
currentBud.lateralDir = Vector3.Normalize(eta * tropismVec + epsilon * currentBud.optimalGrowth + (1 - eta - epsilon) * currentBud.dir);
Vector3 newLateralBudPosition = currentBud.pos + currentBud.lateralDir * internodeLength;
Bud newLateralBud = new Bud(newLateralBudPosition, true);
Node <Bud> newLateralNode = new Node <Bud>(ref skeleton, currentNode, newLateralBud);
currentNode.lateral = newLateralNode;
leaves.Add(newLateralNode);
}
private void updateBranchWidth(ref Node <Bud> baseNode)
{
Bud currentBud = baseNode.value;
if (baseNode.isLeaf())
{
currentBud.branchWidth = initialDiameter;
}
else
{
float lateralBudWidth = (baseNode.lateral != null ? baseNode.lateral.value.branchWidth : 0f);
float mainBudWidth = (baseNode.main != null ? baseNode.main.value.branchWidth : 0f);
currentBud.branchWidth = (float)(Math.Pow(lateralBudWidth, this.n) + Math.Pow(mainBudWidth, this.n));
}
}
public Bud AddNewBud(AGrowable parent, float relativePercentPosition = 0f)
{
GameObject gameObject = _assetManager.CreateBud(transform);
Bud growable = new Bud(this, gameObject, relativePercentPosition);
gameObject.GetComponent <GrowableComponent>().Growable = growable;
gameObject.transform.localScale = Vector3.zero;
if (parent != null)
{
parent.AddChild(growable);
}
return(growable);
}
// Evalue la lumière recue pour un bourgeon de l'arbre
private void evaluateLight(ref Node <Bud> N)
{
Bud bud = N.value;
Node <Bud> lateral = N.lateral;
Node <Bud> main = N.main;
if (N.isLeaf())
{
bud.Q = Q_leaf;
}
else
{
bud.Q = (lateral != null ? lateral.value.Q : 0f) + (main != null ? main.value.Q : 0f);
}
}
public void Create_SideBud(Bud bud, bool curveUpward, float k, bool trop)
{
Vector3 curr_direction = bud.get_direction();
int bud_num = Random.Range(min_bud, max_bud);
float angle = 360 / bud_num;
int curr_age = bud.age;
if (trop == false)
{
if (curveUpward == true)
{
for (int i = 0; i < bud_num; i++)
{
Vector3 new_direction = Quaternion.Euler(15.0f, angle * i, 15.0f) * curr_direction;
Vector3 u = new Vector3(0.0f, 1.0f, 0.0f);
new_direction += u * k;
new_direction = new_direction.normalized;
Bud new_bud = new Bud(new_direction, curr_age + 3);
bud_list.Add(new_bud);
}
}
else
{
for (int i = 0; i < bud_num; i++)
{
Vector3 new_direction = Quaternion.Euler(15.0f, angle * i, 15.0f) * curr_direction;
Vector3 H = new Vector3(new_direction.x, 0.0f, new_direction.z);
H = H.normalized;
new_direction += k * H;
new_direction = new_direction.normalized;
Bud new_bud = new Bud(new_direction, curr_age + 2);
bud_list.Add(new_bud);
}
}
}
else
{
for (int i = 0; i < bud_num; i++)
{
Vector3 new_direction = Quaternion.Euler(15.0f, angle * i, 15.0f) * curr_direction;
//Vector3 u = new Vector3(0.0f, 1.0f, 0.0f);
//new_direction += u * k;
//new_direction = new_direction.normalized;
Bud new_bud = new Bud(new_direction.normalized, curr_age + 3);
bud_list.Add(new_bud);
}
}
}
public float theta_rad = 1.3f; // radians
public void execute(ref TreeData tree)
{
float cos_theta = (float)Math.Cos(theta_rad);
foreach (Node <Bud> node in tree.skeleton.leaves)
{
Bud bud = node.value;
List <Vector3> directions = new List <Vector3>();
for (int i = (tree.markers.Count - 1); i >= 0; i--)
{
Vector3 marker = tree.markers[i];
Vector3 vecBetween = (marker - bud.pos);
float distanceBetween = vecBetween.magnitude;
if (distanceBetween <= phi) // in bud sphere
{
tree.markers.RemoveAt(i);
}
}
foreach (Vector3 marker in tree.markers)
{
Vector3 vecBetween = (bud.pos - marker);
float distanceBetween = vecBetween.magnitude;
if (distanceBetween <= r) // maybe in bud cone
{
Vector3 dirToMarker = Vector3.Normalize(vecBetween);
float angleCosBetween = Vector3.Dot(bud.dir, dirToMarker);
if (angleCosBetween > cos_theta) // in bud cone
{
bud.targetMarkers.Add(marker);
directions.Add(dirToMarker);
}
}
}
// optimal growth = average of directions to markers which are inside the bud cone
Vector3 sum = new Vector3(0, 0, 0);
foreach (Vector3 dir in directions)
{
sum += dir;
}
bud.optimalGrowth = sum / directions.Count;
}
}
// Use this for initialization
void Start()
{
// Scripts
generationScript = GameObject.Find("DepthMovingObjects").GetComponent <Generation>();
// Components
thisTransform = transform;
// Init
level = 0;
budSelected = 0;
buds = new Bud[thisTransform.childCount];
for (int i = 0; i < thisTransform.childCount; i++)
{
buds[i] = thisTransform.GetChild(i).GetComponent <Bud>();
}
buds[0].petals[0].setAlive(true);
}
public Bud[] BreakBud(float newWeight) // Returns two buds, the first one has the weight of the parameter, the second has the remaining
{
GameObject pieceOneGO = new GameObject("Bud");
GameObject pieceTwoGO = new GameObject("Bud");
Bud pieceOne = pieceOneGO.AddComponent <Bud>();
Bud pieceTwo = pieceTwoGO.AddComponent <Bud>();
float pieceOneWeight = newWeight;
float pieceTwoWeight = weight - newWeight;
pieceOne.strain = strain;
pieceOne.weight = pieceOneWeight;
pieceTwo.strain = strain;
pieceTwo.weight = pieceTwoWeight;
Bud[] returnArray = new Bud[2];
returnArray[0] = pieceOne;
returnArray[1] = pieceTwo;
StartCoroutine(Broke());
return(returnArray);
}
public void execute(ref TreeData tree)
{
tree.markers = new List <Vector3>(nb_markers);
tree.boundingBox = boundingBox;
for (int i = 0; i < nb_markers; i++)
{
float x = Random.Range(0, tree.boundingBox.x);
float y = Random.Range(0, tree.boundingBox.y);
float z = Random.Range(0, tree.boundingBox.z);
tree.markers.Add(new Vector3(x, y, z));
}
Vector3 budPosition = new Vector3(boundingBox.x / 2, 0, boundingBox.z / 2); // default seed position => bottom
Bud bud = new Bud(budPosition, true);
Node <Bud> root = new Node <Bud>(bud);
tree.skeleton = new TreeGraph <Bud>(root);
}
// Accumule l'énergie de l'arbre, de la base vers les feuilles
private void distributeEnergy(ref TreeGraph <Bud> skeleton)
{
// On évalue d'abord la quantité d'énergie à la base de l'arbre
Bud rootBud = skeleton.root.value;
float vBase = alpha * rootBud.Q;
rootBud.setEnergy(vBase);
for (int i = 0; i < skeleton.levels.Count; i++)
{
List <Node <Bud> > list = skeleton.levels[i];
for (int j = 0; j < list.Count; j++)
{
Node <Bud> node = list[j];
Bud bud = node.value;
evaluateState(ref bud);
evaluateEnergy(ref node);
}
}
}
private void growBranch(ref TreeGraph <Bud> skeleton, ref List <Node <Bud> > leaves, ref Node <Bud> currentNode)
{
Bud currentBud = currentNode.value;
Vector3 dir = currentBud.dir;
float length = currentBud.l;
int it_number = currentBud.n;
Node <Bud> node = currentNode;
for (int i = 1; i < it_number; i++)
{
Node <Bud> previousNode = node;
Bud previousBud = previousNode.value;
Vector3 position = previousBud.pos + dir * length;
Bud bud = new Bud(position, false);
node = new Node <Bud>(ref skeleton, previousNode, bud);
previousNode.main = node;
}
leaves.Add(node);
}
void drawNodeCircles(Color c, bool lateralMode)
{
Gizmos.color = c;
if (treeModel.skeleton != null)
{
foreach (List <Node <Bud> > level in treeModel.skeleton.levels)
{
foreach (Node <Bud> node in level)
{
Bud bud = node.value;
List <Vector3> vertices = null;
if (lateralMode)
{
vertices = bud.lateralVertices;
}
else
{
vertices = bud.mainVertices;
}
if (vertices != null)
{
Vector3 position_start, position_end;
position_start = position_end = new Vector3();
for (int i = 1; i < vertices.Count; i++)
{
position_start = transform.position + vertices[i - 1];
position_end = transform.position + vertices[i];
Gizmos.DrawLine(position_start, position_end);
}
position_start = transform.position + vertices[vertices.Count - 1];
position_end = transform.position + vertices[0];
Gizmos.DrawLine(position_start, position_end);
}
}
}
}
}
public void Bud_Growth(ArrayList node_list, ArrayList internode_list, float k, bool trop)
{
for (int i = 0; i < bud_list.Count; i++)
{
Bud bud = (Bud)bud_list[i];
int curr_age = bud.age;
if (Random.value < bud.prob_die)
{
bud.Set_Dead();
}
else if (Random.value > bud.prob_pause)
{
Vector3 direction = bud.get_direction();
Vector3 new_position = position + node_length * direction;
Bud new_bud = new Bud(direction, curr_age + 1);
Node end_node = new Node(new_bud, new_position, curveUpward, trop);
node_list.Add(end_node);
internode_list.Add(new Internode(this, end_node));
end_node.Create_SideBud(bud, curveUpward, k, trop);
end_node.Create_TipBud(bud);
}
}
}
public void execute(ref TreeData tree)
{
List <Node <Bud> > leaves = tree.skeleton.leaves;
for (int i = leaves.Count - 1; i >= 0; i--)
{
Node <Bud> node = leaves[i];
Bud bud = node.value;
switch (bud.state)
{
case BudState.NEW_METAMER:
growBranch(ref tree.skeleton, ref leaves, ref node);
addMetamer(ref tree.skeleton, ref leaves, ref node);
break;
case BudState.DORMANT:
growBranch(ref tree.skeleton, ref leaves, ref node);
break;
}
leaves.Remove(node);
}
}
// Use this for initialization
void Start()
{
float k = kValueForCurve;
internode_list = new ArrayList();
node_list = new ArrayList();
Random.InitState(random_seed);
Bud start_bud = new Bud(new Vector3(0, 1, 0), 1);
Node start_node = new Node(start_bud, this.transform.position, curveUpward, NoTropicalImplementation);
node_list.Add(start_node);
for (int i = 0; i < growth_cap; i++)
{
int count = node_list.Count;
for (int j = 0; j < count; j++)
{
((Node)node_list[j]).Bud_Growth(node_list, internode_list, k, NoTropicalImplementation);
}
}
foreach (Internode internode in internode_list)
{
int color_coe = internode.start_node.node_bud.age;
draw_internode(internode, color_coe);
if (flower != null)
{
if (internode.end_node.node_bud.age >= 5)
{
Vector3 pos = internode.end_node.position + this.transform.position;
GameObject myFlower = Instantiate(flower, pos, Quaternion.identity) as GameObject;
myFlower.transform.parent = this.transform;
//myFlower.transform.rotation = Random.rotation;
}
}
}
}
// Use this for initialization
void Start()
{
instance = GetComponent <PlantManager>();
starting_position.xGridPosition = 2;
starting_position.yGridPosition = 3;
GameObject gm = Instantiate(grid_marker_prefab, new Vector3(BOARD_START_X + (BOARD_MARKER_MARGIN * 2), BOARD_START_Y - (BOARD_MARKER_MARGIN * 3), 0), grid_marker_prefab.transform.rotation);
starting_position.obj = gm;
// instantiate all grid markers with their position and neighbor knowledge
CreateBoard();
grid_markers[(GRID_WIDTH - 1) / 2, GRID_HEIGHT - 1] = starting_position;
// create initial bud and set position
GameObject original_bud_gm = new GameObject();
Bud original_bud = original_bud_gm.AddComponent <Bud>();
original_bud.current_position = starting_position;
original_bud.growth = original_bud_gm;
original_bud.InstantiateLineRenderer();
bud_list.Add(original_bud);
}
private static void testing(long start, long limit, string expected)
{
Console.WriteLine("start: {0}, limit: {1}, expected: {2}", start, limit, expected);
Assert.AreEqual(expected, Bud.Buddy(start, limit));
}
// Method for generating a plant object
public GameObject generatePlant(string leafColor)
{
// Clear segment list
segments = new List <Segment>();
startSegment(new Vector3(0f, 0f, 0f), 1, 1);
// Grow segments
for (int i = 0; i < growthCycles; i++)
{
// List of new nodes being made
List <Node> newNodes = new List <Node>();
// Grow each segment
foreach (Segment seg in segments)
{
List <Node> segNodes = seg.getNodes();
Bud tipBud = segNodes[segNodes.Count - 1].getTipBud();
int tipBudAge = tipBud.getAge();
// Check if bud should die -> if so then set bud to die
// If it should not die, check if its already dead or should pause growth
float deathValue = Random.value;
if (deathValue <= tipBud.getDiePob() + (0.015f * tipBudAge))
{
//string message = deathValue.ToString() + ", " + (tipBud.getDiePob() + (0.015f * tipBudAge)).ToString();
//Debug.Log(message);
tipBud.setDead();
}
if (!tipBud.getIsDead() && Random.value > tipBud.getPause())
{
Node newNode = seg.grow();
newNodes.Add(newNode);
}
}
//print(newNodes[0].getTipBud().getOrder());
// Start new segments at new nodes' side buds
foreach (Node newNode in newNodes)
{
foreach (Bud sidebud in newNode.getSideBuds())
{
startSegment(sidebud.getPos(), sidebud.getAge(), sidebud.getOrder());
}
}
}
GameObject plant = new GameObject();
plant.name = "Plant";
// Create the segment objects
foreach (Segment seg in segments)
{
GameObject segment = new GameObject();
segment.name = "Segment";
segment.AddComponent <MeshFilter>();
segment.AddComponent <MeshRenderer>();
segment.GetComponent <MeshFilter>().mesh = seg.getMesh();
Renderer rend = segment.GetComponent <Renderer>();
rend.material.color = new Color(0.5f, 0.2f, 0.05f, 1.0f); // bark color
segment.transform.parent = plant.transform;
// Create leaf spheres at the end of each segment
List <Node> segNodes = seg.getNodes();
Bud segTipBud = segNodes[segNodes.Count - 1].getTipBud();
if (segTipBud.getOrder() > 3)
{
GameObject leaf = GameObject.CreatePrimitive(PrimitiveType.Sphere);
leaf.transform.position = segTipBud.getPos();
//leaf.transform.localScale = new Vector3(5f / segTipBud.getOrder(), 5f / segTipBud.getOrder(), 5f / segTipBud.getOrder());
leaf.transform.localScale = new Vector3(2.5f, 2.5f, 2.5f);
// Set leaf color
Color color = new Color(1f, 1f, 1f);
if (leafColor == "Green")
{
color = new Color(0f, Random.value, 0f, 1f); // light green
}
else if (leafColor == "Autumn")
{
color = new Color(0.3f + Random.value, Random.value - 0.5f, 0f, 1f); // autumn colors
}
else if (leafColor == "Sakura")
{
float pinkRandom = Random.Range(0.5f, 0.8f);
color = new Color(1f, pinkRandom, pinkRandom, 1f); // pink
}
leaf.GetComponent <Renderer>().material.color = color;
leaf.transform.parent = plant.transform;
}
}
return(plant);
}
////////// Functions //////////////
// Begins a new segnment by create a tip bud, a node, and the segment object
// Also creates the mesh for the base of the first cylinder
public void startSegment(Vector3 pos, int age, int order)
{
// If this is the first segment of the plant, make its direction up
Vector3 dir;
if (segments.Count == 0)
{
dir = new Vector3(0f, 1f, 0f);
}
else
{
dir = new Vector3((Random.value * 2f) - 1f, 0.1f + Random.value, (Random.value * 2f) - 1f);
//dir = new Vector3((Random.value * 2f) - 1f, Random.value / 1.5f, (Random.value * 2f) - 1f);
//dir = new Vector3(Random.value - 0.5f, 1f + Random.value, Random.value - 0.5f);
}
Bud tipBud = new Bud(pos, dir, age, order);
Node startNode = new Node(pos, tipBud);
Segment newSegment = new Segment(startNode);
// Create cylinder base in mesh
Mesh startMesh = new Mesh();
Vector3[] verts = new Vector3[7];
int[] tris = new int[6 * 3];
Vector3 T = dir.normalized;
Vector3 V = (T.x == 1f) ? new Vector3(0f, 1f, 0f) : new Vector3(1f, 0f, 0f);
Vector3 N = -1f * (Vector3.Cross(T, V)).normalized;
Vector3 B = Vector3.Cross(T, N);
//verts[0] = pos;
//verts[1] = pos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * 0f), 0f, Mathf.Sin(Mathf.Deg2Rad * 0f));
//verts[2] = pos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * 60f), 0f, Mathf.Sin(Mathf.Deg2Rad * 60f));
//verts[3] = pos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * 120f), 0f, Mathf.Sin(Mathf.Deg2Rad * 120f));
//verts[4] = pos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * 180f), 0f, Mathf.Sin(Mathf.Deg2Rad * 180f));
//verts[5] = pos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * 240f), 0f, Mathf.Sin(Mathf.Deg2Rad * 240f));
//verts[6] = pos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * 300f), 0f, Mathf.Sin(Mathf.Deg2Rad * 300f));
verts[0] = pos;
verts[1] = pos + (((N * Mathf.Cos(Mathf.Deg2Rad * 0f)) + (B * Mathf.Sin(Mathf.Deg2Rad * 0f))) / ((age + order) * 1f / 2f));
verts[2] = pos + (((N * Mathf.Cos(Mathf.Deg2Rad * 60f)) + (B * Mathf.Sin(Mathf.Deg2Rad * 60f))) / ((age + order) * 1f / 2f));
verts[3] = pos + (((N * Mathf.Cos(Mathf.Deg2Rad * 120f)) + (B * Mathf.Sin(Mathf.Deg2Rad * 120f))) / ((age + order) * 1f / 2f));
verts[4] = pos + (((N * Mathf.Cos(Mathf.Deg2Rad * 180f)) + (B * Mathf.Sin(Mathf.Deg2Rad * 180f))) / ((age + order) * 1f / 2f));
verts[5] = pos + (((N * Mathf.Cos(Mathf.Deg2Rad * 240f)) + (B * Mathf.Sin(Mathf.Deg2Rad * 240f))) / ((age + order) * 1f / 2f));
verts[6] = pos + (((N * Mathf.Cos(Mathf.Deg2Rad * 300f)) + (B * Mathf.Sin(Mathf.Deg2Rad * 300f))) / ((age + order) * 1f / 2f));
tris[0] = 0;
tris[1] = 2;
tris[2] = 1;
tris[3] = 0;
tris[4] = 3;
tris[5] = 2;
tris[6] = 0;
tris[7] = 4;
tris[8] = 3;
tris[9] = 0;
tris[10] = 5;
tris[11] = 4;
tris[12] = 0;
tris[13] = 6;
tris[14] = 5;
tris[15] = 0;
tris[16] = 1;
tris[17] = 6;
startMesh.vertices = verts;
startMesh.triangles = tris;
startMesh.RecalculateNormals();
newSegment.setMesh(startMesh);
// Add to global list of segments
segments.Add(newSegment);
}
// Grows the segment by adding a new node in the direction
// of the tipNode's tipBud
// Returns the new tipNode
public Node grow()
{
Node tipNode = nodes[nodes.Count - 1];
Bud tipBud = tipNode.getTipBud();
int segOrder = tipBud.getOrder();
int age = tipBud.getAge();
Vector3 oldTipPos = tipBud.getPos();
Vector3 growthDir = tipBud.getDir();
// Get segment's vertices and triangles of mesh
Vector3[] oldVerts = segMesh.vertices;
int[] oldTris = segMesh.triangles;
int oldVertLength = oldVerts.Length;
int oldTriLength = oldTris.Length;
// Create new lists of vertices and tris
Vector3[] newVerts = new Vector3[oldVertLength + 7];
int[] newTris = new int[oldTriLength + (18 * 3)];
// Check if segment is not just a cylinder base in mesh
// If it is multiple cylinders, "cut off" the top cap of the mesh
int stopCopyIndex = (oldVertLength > 7) ? oldTriLength - 18 - 1 : oldTriLength - 1;
for (int v = 0; v < oldVertLength; v++)
{
newVerts[v] = oldVerts[v];
}
for (int t = 0; t <= stopCopyIndex; t++)
{
newTris[t] = oldTris[t];
}
// Calculate new vertices
Vector3 T = growthDir.normalized;
Vector3 V = (T.x == 1f) ? new Vector3(0f, 1f, 0f) : new Vector3(1f, 0f, 0f);
Vector3 N = -1f * (Vector3.Cross(T, V)).normalized;
Vector3 B = Vector3.Cross(T, N);
Vector3 newTipPos = oldTipPos + (T * growthLength);
//newVerts[oldVertLength] = newTipPos;
//newVerts[oldVertLength + 1] = newTipPos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * 0f), 0f, Mathf.Sin(Mathf.Deg2Rad * 0f));
//newVerts[oldVertLength + 2] = newTipPos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * 60f), 0f, Mathf.Sin(Mathf.Deg2Rad * 60f));
//newVerts[oldVertLength + 3] = newTipPos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * 120f), 0f, Mathf.Sin(Mathf.Deg2Rad * 120f));
//newVerts[oldVertLength + 4] = newTipPos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * 180f), 0f, Mathf.Sin(Mathf.Deg2Rad * 180f));
//newVerts[oldVertLength + 5] = newTipPos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * 240f), 0f, Mathf.Sin(Mathf.Deg2Rad * 240f));
//newVerts[oldVertLength + 6] = newTipPos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * 300f), 0f, Mathf.Sin(Mathf.Deg2Rad * 300f));
newVerts[oldVertLength] = newTipPos;
newVerts[oldVertLength + 1] = newTipPos + (((N * Mathf.Cos(Mathf.Deg2Rad * 0f)) + (B * Mathf.Sin(Mathf.Deg2Rad * 0f))) / ((segOrder + age) * 1f / 2f));
newVerts[oldVertLength + 2] = newTipPos + (((N * Mathf.Cos(Mathf.Deg2Rad * 60f)) + (B * Mathf.Sin(Mathf.Deg2Rad * 60f))) / ((segOrder + age) * 1f / 2f));
newVerts[oldVertLength + 3] = newTipPos + (((N * Mathf.Cos(Mathf.Deg2Rad * 120f)) + (B * Mathf.Sin(Mathf.Deg2Rad * 120f))) / ((segOrder + age) * 1f / 2f));
newVerts[oldVertLength + 4] = newTipPos + (((N * Mathf.Cos(Mathf.Deg2Rad * 180f)) + (B * Mathf.Sin(Mathf.Deg2Rad * 180f))) / ((segOrder + age) * 1f / 2f));
newVerts[oldVertLength + 5] = newTipPos + (((N * Mathf.Cos(Mathf.Deg2Rad * 240f)) + (B * Mathf.Sin(Mathf.Deg2Rad * 240f))) / ((segOrder + age) * 1f / 2f));
newVerts[oldVertLength + 6] = newTipPos + (((N * Mathf.Cos(Mathf.Deg2Rad * 300f)) + (B * Mathf.Sin(Mathf.Deg2Rad * 300f))) / ((segOrder + age) * 1f / 2f));
int newVertsLength = newVerts.Length;
// Calculate new tris
// Sides
newTris[oldTriLength] = newVertsLength - 13;
newTris[oldTriLength + 1] = newVertsLength - 12;
newTris[oldTriLength + 2] = newVertsLength - 6;
newTris[oldTriLength + 3] = newVertsLength - 12;
newTris[oldTriLength + 4] = newVertsLength - 5;
newTris[oldTriLength + 5] = newVertsLength - 6;
newTris[oldTriLength + 6] = newVertsLength - 12;
newTris[oldTriLength + 7] = newVertsLength - 11;
newTris[oldTriLength + 8] = newVertsLength - 5;
newTris[oldTriLength + 9] = newVertsLength - 11;
newTris[oldTriLength + 10] = newVertsLength - 4;
newTris[oldTriLength + 11] = newVertsLength - 5;
newTris[oldTriLength + 12] = newVertsLength - 11;
newTris[oldTriLength + 13] = newVertsLength - 10;
newTris[oldTriLength + 14] = newVertsLength - 4;
newTris[oldTriLength + 15] = newVertsLength - 10;
newTris[oldTriLength + 16] = newVertsLength - 3;
newTris[oldTriLength + 17] = newVertsLength - 4;
newTris[oldTriLength + 18] = newVertsLength - 10;
newTris[oldTriLength + 19] = newVertsLength - 9;
newTris[oldTriLength + 20] = newVertsLength - 3;
newTris[oldTriLength + 21] = newVertsLength - 9;
newTris[oldTriLength + 22] = newVertsLength - 2;
newTris[oldTriLength + 23] = newVertsLength - 3;
newTris[oldTriLength + 24] = newVertsLength - 9;
newTris[oldTriLength + 25] = newVertsLength - 8;
newTris[oldTriLength + 26] = newVertsLength - 2;
newTris[oldTriLength + 27] = newVertsLength - 8;
newTris[oldTriLength + 28] = newVertsLength - 1;
newTris[oldTriLength + 29] = newVertsLength - 2;
newTris[oldTriLength + 30] = newVertsLength - 8;
newTris[oldTriLength + 31] = newVertsLength - 13;
newTris[oldTriLength + 32] = newVertsLength - 1;
newTris[oldTriLength + 33] = newVertsLength - 13;
newTris[oldTriLength + 34] = newVertsLength - 6;
newTris[oldTriLength + 35] = newVertsLength - 1;
// New cap
newTris[oldTriLength + 36] = newVertsLength - 7;
newTris[oldTriLength + 37] = newVertsLength - 6;
newTris[oldTriLength + 38] = newVertsLength - 5;
newTris[oldTriLength + 39] = newVertsLength - 7;
newTris[oldTriLength + 40] = newVertsLength - 5;
newTris[oldTriLength + 41] = newVertsLength - 4;
newTris[oldTriLength + 42] = newVertsLength - 7;
newTris[oldTriLength + 43] = newVertsLength - 4;
newTris[oldTriLength + 44] = newVertsLength - 3;
newTris[oldTriLength + 45] = newVertsLength - 7;
newTris[oldTriLength + 46] = newVertsLength - 3;
newTris[oldTriLength + 47] = newVertsLength - 2;
newTris[oldTriLength + 48] = newVertsLength - 7;
newTris[oldTriLength + 49] = newVertsLength - 2;
newTris[oldTriLength + 50] = newVertsLength - 1;
newTris[oldTriLength + 51] = newVertsLength - 7;
newTris[oldTriLength + 52] = newVertsLength - 1;
newTris[oldTriLength + 53] = newVertsLength - 6;
// Make new new tipBud and new tipNode and add it to segment's node list
//Vector3 newTipDir = new Vector3((Random.value * 2f) - 1f, 1f + Random.value, (Random.value * 2f) - 1f);
Vector3 newTipDir = new Vector3(Random.value - 0.5f, 0.25f + Random.value, Random.value - 0.5f);
Bud newTipBud = new Bud(newTipPos, newTipDir, age + 1, segOrder);
Node newTipNode = new Node(newTipPos, newTipBud);
// Add a number of branches at the new node
int numBranches = Random.Range(0, maxSideBudsPerNode);
for (int i = 0; i < numBranches; i++)
{
Vector3 dir = new Vector3((Random.value * 2f) - 1f, Random.value / 4f, (Random.value * 2f) - 1f);
Vector3 sideBudPos = newTipPos - T;
Bud sideBud = new Bud(sideBudPos, dir, age, segOrder + 1);
newTipNode.addSideBud(sideBud);
}
nodes.Add(newTipNode);
// Set the new vertices and triangles for the mesh
segMesh.vertices = newVerts;
segMesh.triangles = newTris;
segMesh.RecalculateNormals();
return(newTipNode);
}
public void addSideBud(Bud bud)
{
this.sideBuds.Add(bud);
}
public Node(Vector3 pos, Bud tipBud)
{
this.pos = pos;
this.sideBuds = new List <Bud>();
this.tipBud = tipBud;
}
