// Use this for initialization
public void StartBranch(int time, int old, Seed_Node nodeOrigine, List <Seed_Node> nodes, Seed set_seed)
{
//init
NodeOrigine = nodeOrigine;
Nodes = nodes;
seed = set_seed;
Time = time + 1;
ActualTime = time;
id_node = 0;
float size = seed.Size_Base;
if (nodes[0].is_secondaire)
{
size = seed.Size_Branch;
}
//set line
gameObject.AddComponent <LineRenderer>();
gameObject.GetComponent <LineRenderer>().SetPosition(0, NodeOrigine.Center);
gameObject.GetComponent <LineRenderer>().SetPosition(1, NodeOrigine.Center);
gameObject.GetComponent <LineRenderer>().material =
Resources.Load("Materials/TreeBase", typeof(Material)) as Material;
SizeBranch = new AnimationCurve(
new Keyframe(0, size), new Keyframe((seed.Old - seed.Maturate) / seed.Old, size), new Keyframe(1, 0.2f));
gameObject.GetComponent <LineRenderer>().widthCurve = SizeBranch;
//invoke
UpdateForTime = (speed / 0.01f) - 1;
InvokeRepeating("UpdateBranch", speed, 0.01f);
InvokeRepeating("UpdateTime", speed * 2, speed);
}
/// <summary>
/// Initializes a new node in a tree. /> class.
/// </summary>
public Seed_Node(int old, Vector3 center, Vector3 angle, Seed_Node parent, int branch, bool is_new_branch = false)
{
Old = old;
Center = center;
Angle = angle;
Parent = parent;
Branch = branch;
is_newBranch = is_new_branch;
}
void UpdateBranch()
{
if (ActualTime == Time) //suivi du node actuel
{
grown += 1 / UpdateForTime;
// set position/rotation
Vector3 pos = Vector3.Lerp(gameObject.GetComponent <LineRenderer>().GetPosition(id_node - 1),
NextNode.Center, grown);
Quaternion rot = Quaternion.LookRotation(
NextNode.Center, gameObject.GetComponent <LineRenderer>().GetPosition(id_node - 1));
// update position?forme de la branche
gameObject.GetComponent <LineRenderer>().SetPosition(id_node, pos);
// rajout feuille
if (!is_Fondamental & Random.Range(0, 99) < seed.Density_Leaf.Evaluate(grown) * seed.Frequence_Leaf)
{
//gen
GameObject leaf = Instantiate(Resources.Load("Prefabs/Leaf_tree", typeof(GameObject)) as GameObject,
pos, rot, transform);
leaf.transform.localScale = new Vector3(seed.Size_Leaf, seed.Size_Leaf, seed.Size_Leaf);
leaf.transform.localRotation = rot;
int sens = 0;
if (Random.Range(0, 99) < 50)
{
sens = 180;
}
leaf.transform.Rotate(new Vector3(0, sens, 0));
}
}
else //suivi du prochain node
{
grown = 0;
ActualTime++;
foreach (Seed_Node node in Nodes)
{
if (node.Old == ActualTime)
{
NextNode = node; //set le prochain node de la branch
}
}
id_node++;
gameObject.GetComponent <LineRenderer>().positionCount = id_node + 1; //set une nouvelle ligne
gameObject.GetComponent <LineRenderer>().SetPosition(id_node,
gameObject.GetComponent <LineRenderer>().GetPosition(id_node - 1)); //set le nouveau point au niveau du precedent
// embranchement
if (NextNode.is_newBranch)
{
transform.parent.parent.GetComponent <BuilderTree>().GenBranch(NextNode, seed, NextNode.newBranch_id);
}
}
if (Time > Old & gameObject.GetComponent <LineRenderer>().GetPosition(id_node - 1) == NextNode.Center & clean)
{
Destroy(this); // clean script
CancelInvoke(); // fin de pousse de la branche
}
}
public void GenTree()
{
if (seed != null)
{
tree = new GameObject("tree");
tree.transform.SetParent(transform);
Seed_Node first_node = new Seed_Node(new Vector3(0, 0, 0));
foreach (Seed_Node node in seed.nodes)
{
if (node.Old == 0)
{
first_node = node;
}
}
GenBranch(first_node, seed, 1);
}
else if (is_debug)
{
Debug.Log("generate the seed for generate the tree");
}
}
public void GenBranch(Seed_Node parent, Seed seed, int id_branch)
{
GameObject branch = new GameObject("branch");
branch.transform.SetParent(tree.transform);
branch.AddComponent <GenBranch>();
//set list node
List <Seed_Node> nodes = new List <Seed_Node>();
foreach (Seed_Node node in seed.nodes)
{
if (node.Branch == id_branch)
{
nodes.Add(node);
}
}
if (is_debug)
{
foreach (Seed_Node node in nodes)
{
Debug.Log("add node time " + node.Old);
}
}
//
if (nodes[0].is_secondaire)
{
branch.GetComponent <GenBranch>().is_Fondamental = false;
}
else
{
branch.GetComponent <GenBranch>().is_Fondamental = true;
}
if (DontCleanScript)
{
branch.GetComponent <GenBranch>().clean = false;
}
branch.GetComponent <GenBranch>().StartBranch(parent.Old, seed.Old, parent, nodes, seed); // start gen
}
public void GenSeed() // generate the seed
{
if (is_debug)
{
Debug.Log("generate seed BEGIN");
}
// instanciate the seed
seed = new Seed(Old, Maturate, Size_Base, Size_Branch, Angle_Branch, First_Branch, Frequence_Branch,
Frequence_Branch_Secondaire, Old_Secondaire, Max_nbr_Fondamental, MaxRank_Fondamental, Angle_Branch_Secondaire,
Frequence_Leaf, Size_Leaf);
seed.Density_Leaf = Density_Leaf;
int time = 0; // Set the time of growning
total_branch = 1;
/*BEGIN creating the seed*/
List <Seed_Node> nodes_parent = new List <Seed_Node>();; // initiate list of parent's node
while (time < Old) // generate Old% node in the seed
{
Seed_Node node; // initiate the node
List <Seed_Node> nodes_parentNew = new List <Seed_Node>();; //reset parent's node
if (is_debug)
{
Debug.Log("Seed: step " + time);
}
/*BEGIN creating the node*/
if (time == 0) // first node
{
//Define angle
Vector3 angle;
angle = RotatePointAroundPivot(new Vector3(0, Distance_nodes, 0), new Vector3(0, 0, 0),
new Vector3(courbure.x + courbure_Secondaire.x, courbure_Secondaire.y, courbure.y + courbure_Secondaire.z));
//Create node
node = new Seed_Node(angle);
seed.nodes.Add(node);
nodes_parentNew.Add(node);
if (is_debug)
{
Debug.Log("Seed: add node in " + node.Center);
}
}
else
{
foreach (Seed_Node parent in nodes_parent) //boucle chaque node créé à la boucle préscedente
{
if (parent.is_secondaire == false ||
time - parent.BornOld_Branch < seed.Old__Branch_Secondaire)
{
node = gen_node(parent);
seed.nodes.Add(node);
nodes_parentNew.Add(node);
bool is_branch = false;
bool is_secondaire;
/* determine si embranchement et secondaire ou fondamental*/
int frequence = seed.Frequence_Branch;
if (seed.Nbr_Branch_Fondamental <= seed.MaxNbr_Branch_Fondamental & parent.Branch_rank < seed.MaxRank_Branch_Fondamental)
{
is_secondaire = false;
}
else
{
is_secondaire = true;
}
if (is_secondaire)
{
frequence = seed.Frequence_Branch_Secondaire;
}
if (time == seed.First_Branch || time > seed.First_Branch & frequence > Random.Range(0, 99))
{
is_branch = true;
}
/**/
if (is_branch)
{
if (!is_secondaire)
{
seed.Nbr_Branch_Fondamental++;
}
Debug.Log(seed.Nbr_Branch_Fondamental);
seed.Nbr_Branch++;
node = gen_node(parent, true, is_secondaire);
seed.nodes.Add(node);
nodes_parentNew.Add(node);
}
}
}
}
/*ENDING creating the node*/
nodes_parent = nodes_parentNew; //set parent
time++;
}
/*ENDING creating the seed*/
GetComponent <BuilderTree>().seed = seed;
if (is_debug)
{
Debug.Log("add seed to genTree");
}
if (is_generate)
{
GetComponent <BuilderTree>().GenTree(); // grown the tree with the seed created
}
}
public Seed_Node gen_node(Seed_Node parent, bool is_newBranch = false, bool is_secondaire_embranchement = false)
{
Seed_Node node;
Vector3 center = parent.Angle;
if (is_newBranch)
{
center = parent.Angle + (parent.Angle - parent.Parent.Center);
center = RotatePointAroundPivot(center, parent.Parent.Center,
new Vector3(-courbure.x, 0, -courbure.y));
if (is_secondaire_embranchement)
{
center = RotatePointAroundPivot(center, parent.Parent.Center,
new Vector3(Random.Range(-seed.Angle_Branch_Secondaire, seed.Angle_Branch_Secondaire), 0,
Random.Range(-seed.Angle_Branch_Secondaire, seed.Angle_Branch_Secondaire)));
}
else
{
center = RotatePointAroundPivot(center, parent.Parent.Center,
new Vector3(Random.Range(-seed.Angle_Branch, seed.Angle_Branch), 0, Random.Range(-seed.Angle_Branch, seed.Angle_Branch)));
}
}
/*Correction emplacement nextNode*/
float distance = Vector3.Distance(center, parent.Center);
center = Vector3.Lerp(parent.Center, center, Distance_nodes / distance);
/**/
Vector3 angle = center + (center - parent.Center);
angle = RotatePointAroundPivot(angle, parent.Center, new Vector3(courbure.x, 0, courbure.y));
if (is_newBranch)
{
parent.is_newBranch = true; //si le début d'une nouvelle branche
}
int branch = parent.Branch;
if (parent.is_newBranch)
{
branch = total_branch;
parent.newBranch_id = total_branch;
total_branch++;
}
node = new Seed_Node(parent.Old + 1, center, angle, parent, branch);
if (parent.is_newBranch)
{
node.BornOld_Branch = parent.Old;
node.Branch_rank = parent.Branch_rank + 1;
if (is_secondaire_embranchement)
{
node.is_secondaire = true;
}
else
{
node.is_secondaire = false;
}
}
else
{
node.is_secondaire = parent.is_secondaire;
node.Branch_rank = parent.Branch_rank;
node.BornOld_Branch = parent.BornOld_Branch;
}
if (is_debug)
{
Debug.Log("Seed: add node in " + node.Center);
}
return(node);
}
