void FixedUpdate()
{
if (inContact) {
if (Physics.Raycast (BrushTip.position, BrushTip.forward, out hit, MaxDrawDistance, DrawMask, QueryTriggerInteraction.Ignore)) {
if (currentPositions.Count == 0 || Vector3.Distance (lastPos, hit.point) > MaxPointDistance) {
lastPos = hit.point;
currentPositions.Add (lastPos);
if (currentPositions.Count > 1) {
currentMark.vertices = new TubeRenderer.TubeVertex [currentPositions.Count];
for (int i = 0; i < currentPositions.Count; i++) {
currentMark.vertices [i] = new TubeRenderer.TubeVertex (currentPositions [i], 0.006f, PaintColor * LightColor);
}
}
var device = SteamVR_Controller.Input ((int)Controller.index);
device.TriggerHapticPulse (250, Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad);
}
} else {
currentMark = null;
inContact = false;
}
} else if (pickingColor) {
if (Physics.Raycast (BrushTip.position, BrushTip.forward, out hit, MaxPickDistance, DrawMask, QueryTriggerInteraction.Ignore)) {
var device = SteamVR_Controller.Input ((int)Controller.index);
device.TriggerHapticPulse (250, Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad);
int width = Mathf.FloorToInt (hit.textureCoord.x * PaletteTexture.width);
int height = Mathf.FloorToInt (hit.textureCoord.y * PaletteTexture.height);
PaintColor = PaletteTexture.GetPixel (width, height);
PaintbrushTip.material.color = PaintColor;
}
}
}
public void GenerateMesh(ref Mesh result)
{
if (result == null)
{
result = new Mesh();
result.hideFlags = HideFlags.HideAndDontSave;
result.MarkDynamic();
}
if (vertices.Count < 2)
{
result.Clear();
return;
}
int additionalVertices = this.brushType == BrushType.Sphere ? 8 : 2;
int actualVertexCount = vertices.Count + additionalVertices;
if (actualVertexCount != meshVertices.Count)
{
if (actualVertexCount < meshVertices.Count)
{
int toRemove = meshVertices.Count - actualVertexCount;
meshVertices.RemoveRange(actualVertexCount, toRemove);
meshTangents.RemoveRange(actualVertexCount, toRemove);
meshNormals.RemoveRange(actualVertexCount, toRemove);
uvs.RemoveRange(actualVertexCount, toRemove);
colors.RemoveRange(actualVertexCount, toRemove);
}
else
{
int toAdd = actualVertexCount - meshVertices.Count;
meshVertices.AddRange(Enumerable.Repeat(default(Vector3), toAdd));
meshTangents.AddRange(Enumerable.Repeat(default(Vector4), toAdd));
meshNormals.AddRange(Enumerable.Repeat(default(Vector3), toAdd));
uvs.AddRange(Enumerable.Repeat(default(Vector2), toAdd));
colors.AddRange(Enumerable.Repeat(default(Color), toAdd));
}
}
int[] indices = null;
TubeRenderer.GenerateMesh(vertices, bufferDataIndex, Flat, Web, brushType, ExtendsMultiplier,
meshVertices, meshTangents, meshNormals, uvs, colors, ref indices, ref currentTotalLength);
result.Clear();
result.SetVertices(meshVertices);
result.SetTangents(meshTangents);
result.SetNormals(meshNormals);
result.SetUVs(0, uvs);
result.SetColors(colors);
result.SetIndices(indices, MeshTopology.Lines, 0, true);
result.RecalculateBounds();
result.UploadMeshData(false);
}
public void SetAtoms(GameObject atom1, GameObject atom2)
{
atompointer1 = atom1;
atompointer2 = atom2;
Vector3[] points = new Vector3[2];
points[0] = atompointer1.transform.position;
points[1] = atompointer2.transform.position;
TubeRenderer tubeRenderer = GetComponent <TubeRenderer>();
tubeRenderer.SetPoints(points, 0.1f, Color.yellow);
}
void OnTriggerExit(Collider other)
{
if (other.CompareTag("Canvas"))
{
currentMark = null;
inContact = false;
}
else if (other.CompareTag("Palette"))
{
pickingColor = false;
}
}
/// <summary>
/// Initialize the object
/// </summary>
/// <param name="data">The data model to use (see Component)</param>
public void Init(LogAnnotationPositionInstance data)
{
Component = data;
Component.Component.AddListener(this);
Component.Container.AddListener(this);
Component.SubDataset.AddListener(this);
Component.AddListener(this);
m_tubeRenderer = gameObject.GetComponent <TubeRenderer>();
ReadPosition();
m_mappedIdx = (Int32[])Component.MappedIndices.Clone();
m_updateColor = m_updatePos = true;
}
protected GameObject CreateRay(string name = "")
{
GameObject ray = new GameObject(name);
ray.transform.SetParent(gameObject.transform, false);
TubeRenderer renderer = ray.AddComponent <TubeRenderer>();
renderer.material = RayMaterial;
renderer.RadiusOne = RayWidth / 2;
renderer.UseWorldSpace = false;
renderer.Sides = 8;
return(ray);
}
private GameObject makeTube()
{
GameObject t = new GameObject("tube");
tr = t.AddComponent <TubeRenderer>();
t.GetComponent <Renderer>().material = m_mat;
tr.material = m_mat;
t.SetActive(true);
t.GetComponent <MeshRenderer>().enabled = true;
tr._radiusOne = 0.002f;
tr._sides = 7;
tr._radiusTwo = 0.002f;
return(t);
}
// Use this for initialization
void Start()
{
tr = gameObject.GetComponent <TubeRenderer>();
if (tr == null)
{
tr = gameObject.AddComponent <TubeRenderer>();
}
ps = GetComponent <ParticleSystem>();
tubes = new List <List <TubeRenderer.TubeVertex> >();
tr.lines = tubes;
for (int i = 0; i < ps.main.maxParticles; i++)
{
}
}
void Start()
{
// Add a TubeRenderer component.
TubeRenderer tube = gameObject.AddComponent <TubeRenderer>();
// Define uv mapping.
tube.uvRect = new Rect(0, 0, 4, 1);
tube.uvRectCap = new Rect(0.543f, 0, 0.33f, 0.33f);
// Set a global radius for the tube.
tube.radius = 0.5f;
// Reduce tube mesh to three edges.
tube.edgeCount = 3;
// Set normal mode to hard edges.
tube.normalMode = TubeRenderer.NormalMode.HardEdges;
// Create point array.
tube.points = new Vector3[POINT_COUNT];
// Define points.
for (int p = 0; p < POINT_COUNT; p++)
{
float norm = p / (POINT_COUNT - 1f);
float angle = norm * Mathf.PI * 2 * 0.7f;
float radius = Mathf.Lerp(2, 0.8f, norm);
float y = Mathf.Lerp(2, 0, norm);
tube.points[p] = new Vector3(Mathf.Cos(angle) * radius, y, Mathf.Sin(angle) * radius);
}
// IMPORTANT! call ForceUpdate to generate the mesh immediately, before adding the MeshCollder.
tube.ForceUpdate();
// Add MeshCollider. The reference to the tube mesh is set automatically.
gameObject.AddComponent <MeshCollider>();
// Create a material at apply it to the tube.
_tileMaterial = new Material(Shader.Find("Diffuse"));
_tileMaterial.mainTexture = Helpers.CreateTileTexture(6);
_tileMaterial.mainTexture.wrapMode = TextureWrapMode.Repeat;
tube.GetComponent <Renderer>().sharedMaterial = _tileMaterial;
// Destroy the TubeRenderer component to free up memory.
Destroy(tube);
// Start the rain.
StartCoroutine(RainCoroutine());
}
// Update is called once per frame
void Update()
{
if (m_model == null)
{
return;
}
lock (m_model)
{
if (!m_model.ShouldUpdate)
{
return;
}
m_model.ShouldUpdate = false;
Func <TubeRenderer> genTubeRenderer = () =>
{
TubeRenderer go = Instantiate(SelectionMeshPrefab);
go.gameObject.SetActive(true);
go.transform.parent = this.transform;
go.transform.localPosition = new Vector3(0.0f, 0.0f, 0.0f);
go.transform.localRotation = Quaternion.identity;
return(go);
};
//Generate objects
for (int i = m_lassoMeshes.Count; i < m_model.LassoPoints.Count; i++)
{
m_lassoMeshes.Add(genTubeRenderer());
}
for (int i = m_connectionMeshes.Count; i < m_model.ConnectionPoints.Count; i++)
{
m_connectionMeshes.Add(genTubeRenderer());
}
//Update objects
for (int i = 0; i < m_model.LassoPoints.Count; i++)
{
m_lassoMeshes[i].SetPositions(m_model.LassoPoints[i].ToArray());
}
for (int i = 0; i < m_model.ConnectionPoints.Count; i++)
{
m_connectionMeshes[i].SetPositions(m_model.ConnectionPoints[i].ToArray());
}
}
}
void OnTriggerEnter(Collider other)
{
if (other.CompareTag ("Canvas")) {
currentMark = new GameObject ("BrushStroke").AddComponent <TubeRenderer> ();
currentMark.gameObject.layer = gameObject.layer;
currentMark.transform.parent = other.transform;
currentMark.MainCamera = MainCamera;
currentMark.material = new Material (PaintMaterial);
currentMark.material.color = PaintColor * LightColor;
currentPositions.Clear ();
var device = SteamVR_Controller.Input ((int)Controller.index);
device.TriggerHapticPulse (500, Valve.VR.EVRButtonId.k_EButton_SteamVR_Trigger);
inContact = true;
} else if (other.CompareTag ("Palette")) {
pickingColor = true;
}
}
/// <summary>
/// When TriggerPressed, two options for behaviour. If user is currently pointing at object, notify object on event. Otherwise, show tooltip.
/// <returns></returns>
///
private void Controller_TriggerPressed(object sender, ControllerInteractionEventArgs e)
{
//If still on an object
triggerPressed = true;
TubeRenderer closestTube = pickingTube(this.transform.position, this.transform.position + this.transform.forward * sizeRay);
if (closestTube != null)
{
//closestTube.GetComponent<Renderer>().material.color = lineRenderer.material.color;
var p1 = closestTube.p1;
var p2 = closestTube.p2;
m1 = p1.draw_map(pointer.transform.parent.transform);
m2 = p2.draw_map(pointer.transform.parent.transform);
//m1.transform.position = p1.transform //m1.transform.position = p1.transform
m1.link_two_maps(m2);
cp1 = m1.transform.parent;
cp2 = m2.transform.parent;
m1.transform.parent = pointer.transform;
m2.transform.parent = pointer.transform;
reset_parents = true;
}
else if (currentObject != null)
{
//Do something on click
GameObject go = currentObject.OnTriggerPressed(pointer.transform.parent.transform);
if (go != null)
{
GetComponent <VRTK_InteractGrab>().AttemptGrabObject(go);
}
}
else
{
helpTooltipState = !helpTooltipState;
helpTooltip.ToggleTips(helpTooltipState);
}
}
private void Update()
{
//CREATE CAT
if (Input.touchCount == 1 && canCreateCat)
{
if (!EventSystem.current.IsPointerOverGameObject(Input.GetTouch(0).fingerId))
{
if (uiManager.currentState == UIScript.GameState.GameScreen)
{
CreateCat();
}
}
}
//DELETE CAT
if (Input.touchCount == 1)
{
if (Input.GetTouch(0).tapCount == 2)
{
touch = Input.GetTouch(0);
if (Physics.Raycast(cam.ScreenPointToRay(touch.position), out catHit, 10f))
{
if (catHit.collider != null)
{
tube = catHit.collider.transform.parent.GetComponent <TubeRenderer>();
myPointsScript = catHit.collider.transform.parent.GetComponent <PointsListScript>();
StartCoroutine(DeleteHead());
uiManager.SetGameScreen();
changeColorScript.ResetColorCycle();
}
}
}
}
if (Input.touchCount == 1)
{
if (Input.GetTouch(0).phase == TouchPhase.Ended)
{
if (listGO == null || root == null)
{
StartCoroutine(ResetCat());
}
}
}
}
public Critter()
{
// create game object and add TubeRenderer component
tube = new GameObject( "Critter" ).AddComponent<TubeRenderer>();
// optimise for realtime manipulation
tube.MarkDynamic();
// define uv mapping for the end caps
tube.uvRectCap = new Rect( 0, 0, 4/12f, 4/12f );
// define points and radiuses
tube.points = new Vector3[ POINT_COUNT ];
tube.radiuses = new float[ POINT_COUNT ];
for( int p = 0; p < POINT_COUNT; p++ ){
tube.points[p] = SmoothRandom( - p * POINT_INTERVAL );
tube.radiuses[p] = Mathf.Lerp( 0.2f, 0.05f, p/(POINT_COUNT-1f ) );
}
}
TubeRenderer pickingTube(Vector3 P1S1, Vector3 P1S2)
{
Dictionary <int, TubeRenderer> tubeList = UnbundleScript.tubeList;
float minDist = 1000;
TubeRenderer tubeClosest = null;
int idClosestTube = -1;
//bool found = false;
foreach (KeyValuePair <int, TubeRenderer> entry in tubeList)
{
if (!selectedTube.Contains(entry.Key))
{
float locMidDist = 1000;
Vector3[] points = entry.Value.points;
for (int i = 1; i < points.Length; i++)
{
float dist = SegmentUtils.Dist_Segments(points[i - 1], points[i], P1S1, P1S2);
if (dist < locMidDist)
{
locMidDist = dist;
}
}
if (locMidDist < minDist)
{
minDist = locMidDist;
idClosestTube = entry.Key;
tubeClosest = entry.Value;
}
}
}
if (minDist < 0.01f)
{
selectedTube.Add(idClosestTube);
return(tubeClosest);
}
return(null);
}
void OnTriggerEnter(Collider other)
{
if (other.CompareTag("Canvas"))
{
currentMark = new GameObject("BrushStroke").AddComponent <TubeRenderer> ();
currentMark.gameObject.layer = gameObject.layer;
currentMark.transform.parent = other.transform;
currentMark.MainCamera = MainCamera;
currentMark.material = new Material(PaintMaterial);
currentMark.material.color = PaintColor * LightColor;
currentPositions.Clear();
var device = SteamVR_Controller.Input((int)Controller.index);
device.TriggerHapticPulse(500, Valve.VR.EVRButtonId.k_EButton_SteamVR_Trigger);
inContact = true;
}
else if (other.CompareTag("Palette"))
{
pickingColor = true;
}
}
// Start is called before the first frame update
void Start()
{
tube = gameObject.GetComponent<TubeRenderer>();
myList = new List<Vector3>();
/*
int arrayNum = 0;
myArray = new Vector3[25];
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
myArray[arrayNum] = new Vector3(i, 0, j);
arrayNum++;
}
}
tube.SetPoints(myArray, 0.5f, Color.white);
tube.material = new Material(Shader.Find("Standard"));
*/
}
public Critter()
{
// Create game object and add TubeRenderer component.
tube = new GameObject("Critter").AddComponent <TubeRenderer>();
// Optimise for realtime manipulation.
tube.MarkDynamic();
// Define uv mapping for the end caps.
tube.uvRectCap = new Rect(0, 0, 4 / 12f, 4 / 12f);
// Define points and radiuses.
tube.points = new Vector3[POINT_COUNT];
tube.radiuses = new float[POINT_COUNT];
for (int p = 0; p < POINT_COUNT; p++)
{
tube.points[p] = SmoothRandom(-p * POINT_SPACING);
tube.radiuses[p] = Mathf.Lerp(0.2f, 0.05f, p / (POINT_COUNT - 1f));
}
}
void FixedUpdate()
{
if (inContact)
{
if (Physics.Raycast(BrushTip.position, BrushTip.forward, out hit, MaxDrawDistance, DrawMask, QueryTriggerInteraction.Ignore))
{
if (currentPositions.Count == 0 || Vector3.Distance(lastPos, hit.point) > MaxPointDistance)
{
lastPos = hit.point;
currentPositions.Add(lastPos);
if (currentPositions.Count > 1)
{
currentMark.vertices = new TubeRenderer.TubeVertex [currentPositions.Count];
for (int i = 0; i < currentPositions.Count; i++)
{
currentMark.vertices [i] = new TubeRenderer.TubeVertex(currentPositions [i], 0.006f, PaintColor * LightColor);
}
}
var device = SteamVR_Controller.Input((int)Controller.index);
device.TriggerHapticPulse(250, Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad);
}
}
else
{
currentMark = null;
inContact = false;
}
}
else if (pickingColor)
{
if (Physics.Raycast(BrushTip.position, BrushTip.forward, out hit, MaxPickDistance, DrawMask, QueryTriggerInteraction.Ignore))
{
var device = SteamVR_Controller.Input((int)Controller.index);
device.TriggerHapticPulse(250, Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad);
int width = Mathf.FloorToInt(hit.textureCoord.x * PaletteTexture.width);
int height = Mathf.FloorToInt(hit.textureCoord.y * PaletteTexture.height);
PaintColor = PaletteTexture.GetPixel(width, height);
PaintbrushTip.material.color = PaintColor;
}
}
}
void Start()
{
// Create tubes for outer and inner surface.
_outerTube = new GameObject("Outer Tube").AddComponent <TubeRenderer>();
_innerTube = new GameObject("Inner Tube").AddComponent <TubeRenderer>();
_outerTube.transform.parent = transform;
_innerTube.transform.parent = transform;
// Optimise for realtime manipulation.
_outerTube.MarkDynamic();
_innerTube.MarkDynamic();
// Invert the mesh of the inner tube.
_innerTube.invertMesh = true;
// Only cap the beginning of the tubes.
_outerTube.caps = TubeRenderer.CapMode.Begin;
_innerTube.caps = TubeRenderer.CapMode.Begin;
// Create point and radius arrays.
_outerTube.points = new Vector3[POINT_COUNT];
_outerTube.radiuses = new float[POINT_COUNT];
_innerTube.points = new Vector3[POINT_COUNT + 1];
_innerTube.radiuses = new float[POINT_COUNT + 1];
// Define points.
for (int p = 0; p < POINT_COUNT; p++)
{
float norm = p / (POINT_COUNT - 1f);
_outerTube.points[p] = Vector3.right * Mathf.Lerp(0.6f, -0.4f, norm);
_innerTube.points[p] = _outerTube.points[p];
}
_innerTube.points[POINT_COUNT] = _innerTube.points[POINT_COUNT - 1]; // double last point
// Add a texutre and adjust the uv mapping of the caps.
_outerTube.GetComponent <Renderer>().sharedMaterial.mainTexture = TubeRendererExamples.Helpers.CreateTileTexture(12);
_innerTube.GetComponent <Renderer>().sharedMaterial.mainTexture = _outerTube.GetComponent <Renderer>().sharedMaterial.mainTexture;
_outerTube.uvRectCap = new Rect(0, 0, 4 / 12f, 4 / 12f);
_innerTube.uvRectCap = _outerTube.uvRectCap;
}
void Start()
{
// Add TubeRenderer component.
_tube = gameObject.AddComponent <TubeRenderer>();
// Optimise for realtime manipulation.
_tube.MarkDynamic();
// No caps please.
_tube.caps = TubeRenderer.CapMode.None;
// Create point and radius arrays.
_tube.points = new Vector3[POINT_COUNT];
_tube.radiuses = new float[POINT_COUNT];
// Define radiuses.
for (int p = 0; p < POINT_COUNT; p++)
{
float norm = p / (POINT_COUNT - 1f);
_tube.radiuses[p] = Mathf.Cos(norm * Mathf.PI * 0.5f) * 0.4f;
}
// Create tiled texture and assign it to the tube.
_tube.GetComponent <Renderer>().sharedMaterial.mainTexture = TubeRendererExamples.Helpers.CreateTileTexture(12);
// Position.
_tube.transform.position = -Vector3.forward * RADIUS;
// Create a bunch of other objects and share the tube mesh.
for (int t = 1; t < TUBE_COUNT; t++)
{
float angle = (t / (float)TUBE_COUNT) * 360;
GameObject cloneTube = new GameObject("Clone Tube");
cloneTube.transform.rotation = Quaternion.Euler(0, angle, 0);
cloneTube.transform.position = cloneTube.transform.rotation * -Vector3.forward * RADIUS;
cloneTube.AddComponent <MeshFilter>().sharedMesh = _tube.mesh;
cloneTube.AddComponent <MeshRenderer>().sharedMaterial = _tube.GetComponent <Renderer>().sharedMaterial;
}
}
void drawTube()
{
if (LineRendererDrawing)
{
Debug.Log("Tube Creation");
int countTube = 0;
int idVec = 0;
foreach (Tuple <GameObject, GameObject, float> kv in pointsList)
{
GameObject tubeGO = new GameObject("Tube-" + countTube);
//tubeGO.transform.SetParent(this.transform);
TubeRenderer lr = tubeGO.AddComponent <TubeRenderer>();
Vector3[] pointsTube = new Vector3[lineLenght];
int idBegining = idVec;
for (int i = idVec; i < idBegining + lineLenght; i++)
{
//Debug.Log(i + ";" + idVec + ";" + idBegining);
pointsTube[i - idBegining] = lineTab[idVec];
idVec++;
}
//lr.positionCount = pointsTube.Length;
//lr.SetPositions(pointsTube);
//lr.startWidth = kv.Item3;
//lr.endWidth = kv.Item3;
//Material[] matArray = new Marterial[1];
//linkMat.color = colorT;
//matArray[0] = linkMat;
//lr.materials = matArray;
lr.radius = kv.Item3;
lr.points = pointsTube;
tubeList.Add(idBegining, lr);
//tubeGO.tag = "Tube";
countTube++;
}
}
}
int createMesh(Vector3[] positions, int i, int multiplier, Color color1, Color color2, int sum, int nbrOfPrevious, string tag, int localPrev)
{
GameObject rh = createObject(RibbonHolder, Vector3.zero);
tubeRenderer = rh.GetComponent <TubeRenderer> ();
if (tag == "ribbons")
{
tubeRenderer.SetPoints(positions, radius, i, multiplier, color1, color2, sum, nbrOfPrevious, localPrev);
}
else
{
tubeRenderer.SetPoints(positions, 0.5f, color1, color2, sum, nbrOfPrevious);
}
tubeRenderer.transform.parent = root.transform;
rh.tag = tag;
rh.GetComponent <MeshRenderer> ().enabled = false;
return(positions.Length);
}
void Start()
{
// add TubeRenderer component
tube = gameObject.AddComponent<TubeRenderer>();
// optimise for realtime manipulation
tube.MarkDynamic();
// no caps please
tube.caps = TubeRenderer.CapMode.None;
// create point and radius arrays
tube.points = new Vector3[POINT_COUNT];
tube.radiuses = new float[POINT_COUNT];
// define radiuses //
for( int p=0; p<POINT_COUNT; p++ ){
float norm = p / (POINT_COUNT-1f);
tube.radiuses[p] = Mathf.Cos( norm * Mathf.PI * 0.5f ) * 0.4f;
}
// create tiled texture and assign it to the tube
tube.GetComponent<Renderer>().sharedMaterial.mainTexture = TubeRendererExamples.Helpers.CreateTileTexture( 12 );
// position //
tube.transform.position = -Vector3.forward * RADIUS;
// create a bunch of other objects and share the tube mesh
for( int t=1; t<TUBE_COUNT; t++ ){
float angle = ( t / (float) TUBE_COUNT ) * 360;
GameObject cloneTube = new GameObject( "Clone Tube" );
cloneTube.transform.rotation = Quaternion.Euler( 0, angle, 0 );
cloneTube.transform.position = cloneTube.transform.rotation * -Vector3.forward * RADIUS;
cloneTube.AddComponent<MeshFilter>().sharedMesh = tube.mesh;
cloneTube.AddComponent<MeshRenderer>().sharedMaterial = tube.GetComponent<Renderer>().sharedMaterial;
}
}
void Start()
{
// Add TubeRendeder component.
_tube = gameObject.AddComponent <TubeRenderer>();
// Optimise for realtime manipulation.
_tube.MarkDynamic();
// Create point and radius arrays.
_tube.points = new Vector3[POINT_COUNT];
_tube.radiuses = new float[POINT_COUNT];
// Define points.
for (int p = 0; p < POINT_COUNT; p++)
{
float norm = p / (POINT_COUNT - 1f);
float x = Mathf.Lerp(-1.5f, 1.5f, norm);
float y = Mathf.Lerp(-1f, 1f, Mathf.PerlinNoise(0, norm));
float z = Mathf.Lerp(-1f, 1f, Mathf.PerlinNoise(norm * 2, 0));
_tube.points[p] = new Vector3(x, y, z);
}
// Set a texture and a uv mapping.
_tube.GetComponent <Renderer>().material.mainTexture = Helpers.CreateTileTexture(12);
_tube.GetComponent <Renderer>().material.mainTexture.wrapMode = TextureWrapMode.Repeat;
_tube.uvRect = new Rect(0, 0, 6, 1);
_tube.uvRectCap = new Rect(0, 0, 4 / 12f, 4 / 12f);
// Create an array to hold animated radiuses.
_normalizedRadiuses = new float[POINT_COUNT];
// Enable post processing by assigning a callback method.
_tube.AddPostprocess(Distort);
// Display mesh gizmos for debugging. this is convinient when you write your own post process method.
_tube.showMeshGizmos = true;
}
public override void MakeArt()
{
GameObject g = new GameObject();
g.transform.SetParent(root.transform);
TubeRenderer tube = g.AddComponent <TubeRenderer>();
Vector3[] vecs = new Vector3[detail];
float[] radius = new float[detail];
float r = Random.value * 1000;
float mult = Random.Range(.0005f, .02f);
for (int i = 0; i < detail; i++)
{
float j = (float)i * mult + r;
vecs[i] = new Vector3(
Mathf.PerlinNoise(j * 4.3321f, j) - .5f,
Mathf.PerlinNoise(j, j * 3.342f) - .5f,
Mathf.PerlinNoise(j * 4.3321f, j * .345f) - .5f) * 2;
radius[i] = (Mathf.Cos(((float)i / (float)detail) * Mathf.PI * 2) - 1) * -.015f;
}
tube.SetPoints(vecs, radius, Color.white);
tube.material = new Material(Shader.Find("Standard"));
GameObject g2 = Instantiate(g);
g2.transform.localScale = new Vector3(-1, 1, 1);
g2.transform.SetParent(g.transform);
for (int i = 1; i < 4; i++)
{
GameObject b = Instantiate(g);
b.transform.localEulerAngles = new Vector3(0, 0, i * 90);
b.transform.SetParent(root.transform);
}
}
void Awake()
{
tube = target as TubeRenderer;
}
void OnTriggerExit(Collider other)
{
if (other.CompareTag ("Canvas")) {
currentMark = null;
inContact = false;
} else if (other.CompareTag ("Palette")) {
pickingColor = false;
}
}
void BuildRope()
{
tubeRenderer = new GameObject("TubeRenderer_" + gameObject.name);
line = tubeRenderer.AddComponent(typeof(TubeRenderer)) as TubeRenderer;
line.useMeshCollision = useMeshCollision;
// Find the amount of segments based on the distance and resolution
// Example: [resolution of 1.0 = 1 joint per unit of distance]
segments = Mathf.RoundToInt(Vector3.Distance(transform.position,target.position)*resolution);
if(material)
{
material.SetTextureScale("_MainTex", new Vector2(1,segments+2));
if(material.GetTexture("_BumpMap"))
material.SetTextureScale("_BumpMap", new Vector2(1,segments+2));
}
line.vertices = new TubeVertex[segments];
line.crossSegments = radialSegments;
line.material = material;
segmentPos = new Vector3[segments];
joints = new GameObject[segments];
segmentPos[0] = transform.position;
segmentPos[segments-1] = target.position;
// Find the distance between each segment
int segs = segments-1;
Vector3 seperation = ((target.position - transform.position)/segs);
for(int s=0;s < segments;s++)
{
// Find the each segments position using the slope from above
Vector3 vector = (seperation*s) + transform.position;
segmentPos[s] = vector;
//Add Physics to the segments
AddJointPhysics(s);
}
// Attach the joints to the target object and parent it to this object
CharacterJoint end = target.gameObject.AddComponent(typeof(CharacterJoint)) as CharacterJoint;
end.connectedBody = joints[joints.Length-1].transform.rigidbody;
end.swingAxis = swingAxis;
SoftJointLimit sjl;
sjl = end.lowTwistLimit;
sjl.limit = lowTwistLimit;
end.lowTwistLimit = sjl;
sjl = end.highTwistLimit;
sjl.limit = highTwistLimit;
end.highTwistLimit = sjl;
sjl = end.swing1Limit;
sjl.limit = swing1Limit;
end.swing1Limit = sjl;
target.parent = transform;
if(endRestrained)
{
end.rigidbody.isKinematic = true;
}
if(startRestrained)
{
transform.rigidbody.isKinematic = true;
}
// Rope = true, The rope now exists in the scene!
rope = true;
}
void Start()
{
// add TubeRendeder component
tube = gameObject.AddComponent<TubeRenderer>();
// optimise for realtime manipulation
tube.MarkDynamic();
// create point and radius arrays
tube.points = new Vector3[POINT_COUNT];
tube.radiuses = new float[POINT_COUNT];
// define points
for( int p=0; p<POINT_COUNT; p++ ){
float norm = p / (POINT_COUNT-1f);
float x = Mathf.Lerp( -1.5f, 1.5f, norm );
float y = Mathf.Lerp( -1f, 1f, Mathf.PerlinNoise( 0, norm ) );
float z = Mathf.Lerp( -1f, 1f, Mathf.PerlinNoise( norm*2, 0 ) );
tube.points[p] = new Vector3( x, y, z );
}
// set a texture and a uv mapping
tube.GetComponent<Renderer>().material.mainTexture = Helpers.CreateTileTexture(12);
tube.GetComponent<Renderer>().material.mainTexture.wrapMode = TextureWrapMode.Repeat;
tube.uvRect = new Rect( 0, 0, 6, 1 );
tube.uvRectCap = new Rect( 0, 0, 4/12f, 4/12f );
// create an array to hold animated radiuses
normalizedRadiuses = new float[ POINT_COUNT ];
// enable post processing by assigning a callback method
tube.AddPostprocess( Distort );
// display mesh gizmos for debugging. this is convinient when you write your own post process method
tube.meshGizmos = true;
}
void Update()
{
if (Caster.Mode == CasterMode.Cooldown)
{
DrawingCamera.clearFlags = CameraClearFlags.SolidColor;
DrawingCamera.backgroundColor = Color.clear;
return;
}
else
{
DrawingCamera.clearFlags = CameraClearFlags.Nothing;
}
if (DrawingCamera.targetTexture == null)
{
DrawingCamera.targetTexture = Resources.Load("SpellCanvasRT") as RenderTexture;
}
if (Caster.Drawing)
{
/*float movement = Vector3.Distance (brushStrokePosition, positionLastFrame);
* if (movement >= MovementThreshold) {
* strokeOpacityTarget = 1f;
* } else {
* strokeOpacityTarget = 0f;
* }
* strokeOpacity = Mathf.Lerp (strokeOpacity, strokeOpacityTarget, Time.deltaTime * BrushFadeSpeed);*/
strokeOpacity = 1f;
float distanceFromCenter = Vector3.Distance(CanvasTr.position, BrushParent.TransformPoint(brushStrokePosition));
if (distanceFromCenter > CanvasRadius)
{
float fadeAmount = 1f - Mathf.Clamp(distanceFromCenter - CanvasRadius, 0, CanvasFadePoint) / CanvasFadePoint;
strokeOpacity *= fadeAmount;
}
brushStrokePosition.z = -50f;
brushStrokePosition.x = Caster.CurrentUVs.x * CanvasScale;
brushStrokePosition.y = Caster.CurrentUVs.y * CanvasScale;
Brush.localPosition = brushStrokePosition;
if (currentMark == null)
{
currentMark = new GameObject("BrushStroke").AddComponent <TubeRenderer> ();
currentMark.gameObject.layer = gameObject.layer;
currentMark.transform.parent = BrushParent;
currentMark.MainCamera = TubeRendererCamera;
currentMark.material = new Material(PaintMaterial);
currentMark.material.color = Color.white;
currentPositions.Clear();
}
Debug.Log(strokeOpacity);
if (currentPositions.Count == 0 || Vector3.Distance(lastBrushStrokePos, brushStrokePosition) > MaxPointDistance)
{
lastBrushStrokePos = brushStrokePosition;
lastStrokeOpacity = strokeOpacity;
currentOpacities.Add(lastStrokeOpacity);
currentPositions.Add(lastBrushStrokePos);
if (currentPositions.Count > 1)
{
currentMark.vertices = new TubeRenderer.TubeVertex [currentPositions.Count];
for (int i = 0; i < currentPositions.Count; i++)
{
currentMark.vertices [i] = new TubeRenderer.TubeVertex(
BrushParent.TransformPoint(currentPositions [i]),
StrokeRadius,
Color.Lerp(Color.black, Color.white, currentOpacities [i]));
}
}
}
}
else
{
currentMark = null;
}
positionLastFrame = brushStrokePosition;
}
void CreateCat()
{
if (Input.GetTouch(0).phase == TouchPhase.Began)
{
listGO = Instantiate(listObj, root.transform);
myPointsScript = listGO.GetComponent <PointsListScript>();
myList = myPointsScript.pointsList;
tube = listGO.GetComponent <TubeRenderer>();
touch = Input.GetTouch(0);
if (Physics.Raycast(cam.ScreenPointToRay(touch.position), out rayHit, 3f))
{
GameObject tailGO = Instantiate(catTailObj, listGO.transform);
tailGO.transform.localScale = Vector3.zero;
tailGO.transform.position = rayHit.point;
myPointsScript.AddPoint(tailGO.transform.position);
tube.vertices = new TubeRenderer.TubeVertex[30];
for (int i = 0; i < tube.vertices.Length; i++)
{
tube.vertices[i] = new TubeRenderer.TubeVertex(Vector3.zero, 1, Color.white);
}
}
}
if (Input.GetTouch(0).phase == TouchPhase.Moved || Input.GetTouch(0).phase == TouchPhase.Stationary)
{
touch = Input.GetTouch(0);
if (Physics.Raycast(cam.ScreenPointToRay(touch.position), out rayHit, 3f))
{
if (Vector3.Distance(myList[myList.Count - 1], rayHit.point) > minDistance)
{
myPointsScript.AddPoint(rayHit.point);
tube.SetPoints(myPointsScript.splineArray, myPointsScript.radiusArray, Color.white);
}
}
}
if (Input.GetTouch(0).phase == TouchPhase.Ended)
{
touch = Input.GetTouch(0);
if (Physics.Raycast(cam.ScreenPointToRay(touch.position), out rayHit, 3f))
{
GameObject headGO = Instantiate(catHeadObj, listGO.transform);
headGO.transform.localScale = Vector3.zero;
headGO.transform.position = myPointsScript.splineArray[myPointsScript.splineArray.Length - 1];
tube.SetPoints(myPointsScript.splineArray, myPointsScript.radius, Color.white);
for (int i = 1; i < myPointsScript.splineArray.Length; i++)
{
GameObject bodyGO = Instantiate(catColliderObj, listGO.transform);
bodyGO.transform.position = myPointsScript.splineArray[i];
bodyGO.transform.SetSiblingIndex(i);
}
}
if (myList.Count < 3)
{
planeObj.SetActive(false);
canCreateCat = false;
StartCoroutine(ResetCat());
}
else
{
if (openSsInstructions)
{
StartCoroutine(OpenSsInstructionsScreen());
}
else
{
uiManager.SetScreenshotScreen();
}
planeObj.SetActive(false);
canCreateCat = false;
}
}
}
void BuildRope()
{
tubeRenderer = new GameObject("TubeRenderer_" + gameObject.name);
line = tubeRenderer.AddComponent(typeof(TubeRenderer)) as TubeRenderer;
line.useMeshCollision = useMeshCollision;
// Find the amount of segments based on the distance and resolution
// Example: [resolution of 1.0 = 1 joint per unit of distance]
segments = Mathf.RoundToInt(Vector3.Distance(transform.position, target.position) * resolution);
if (material)
{
material.SetTextureScale("_MainTex", new Vector2(1, segments + 2));
if (material.GetTexture("_BumpMap"))
{
material.SetTextureScale("_BumpMap", new Vector2(1, segments + 2));
}
}
line.vertices = new TubeVertex[segments];
line.crossSegments = radialSegments;
line.material = material;
segmentPos = new Vector3[segments];
joints = new GameObject[segments];
segmentPos[0] = transform.position;
segmentPos[segments - 1] = target.position;
// Find the distance between each segment
int segs = segments - 1;
Vector3 seperation = ((target.position - transform.position) / segs);
for (int s = 0; s < segments; s++)
{
// Find the each segments position using the slope from above
Vector3 vector = (seperation * s) + transform.position;
segmentPos[s] = vector;
//Add Physics to the segments
AddJointPhysics(s);
}
// Attach the joints to the target object and parent it to this object
CharacterJoint end = target.gameObject.AddComponent(typeof(CharacterJoint)) as CharacterJoint;
end.connectedBody = joints[joints.Length - 1].transform.GetComponent <Rigidbody>();
end.swingAxis = swingAxis;
SoftJointLimit sjl;
sjl = end.lowTwistLimit;
sjl.limit = lowTwistLimit;
end.lowTwistLimit = sjl;
sjl = end.highTwistLimit;
sjl.limit = highTwistLimit;
end.highTwistLimit = sjl;
sjl = end.swing1Limit;
sjl.limit = swing1Limit;
end.swing1Limit = sjl;
target.parent = transform;
if (endRestrained)
{
end.GetComponent <Rigidbody>().isKinematic = true;
}
if (startRestrained)
{
transform.GetComponent <Rigidbody>().isKinematic = true;
}
// Rope = true, The rope now exists in the scene!
rope = true;
}
public void BuildRopeJoints()
{
int newSegments = 0;
int allSegments = (int)(Vector3.Distance(transform.position, target.position) * resolution);
if (_segments == 0)
{
_segments = newSegments = allSegments;
if (_segmentPos.Count < 1)
{
_segmentPos.Add(transform.position);
_segmentPos.Add(target.position);
}
}
else
{
newSegments = allSegments - _segments;
_segments = allSegments;
}
while (newSegments < 0)
{
_segmentPos.RemoveAt(1);
Destroy(_joints[1]);
_joints.RemoveAt(1);
_line.vertices = new TubeVertex[_segments];
newSegments++;
}
if (newSegments == 0)
{
if (target != null)
{
// Does rope exist? If so, update its position
if (_rope)
{
_line.SetPoints(_segmentPos, ropeWidth, Color.white);
_line.enabled = true;
_segmentPos[0] = transform.position;
for (int s = 1; s < _segments; s++)
{
_segmentPos[s] = _joints[s].transform.position;
}
}
}
return;
}
if (_tubeRenderer == null)
{
_tubeRenderer = new GameObject("TubeRenderer_" + gameObject.name);
_line = _tubeRenderer.AddComponent <TubeRenderer>();
_line.useMeshCollision = useMeshCollision;
if (material != null)
{
material.SetTextureScale("_MainTex", new Vector2(1, _segments + 2));
if (material.GetTexture("_BumpMap") != null)
{
material.SetTextureScale("_BumpMap", new Vector2(1, _segments + 2));
}
}
_line.crossSegments = radialSegments;
_line.material = material;
}
_line.vertices = new TubeVertex[_segments];
_segmentPos.InsertRange(1, new Vector3[newSegments]);
//Ensure start and end are correct
_segmentPos[0] = transform.position; //probably unneeded
_segmentPos[_segmentPos.Count - 1] = target.position;
//joints something
AddJointPhysics(0); //Add Joint to object this script is attached to. In this case probably the hook gun
int segs = _segments - 1;
Vector3 seperation = (target.position - transform.position) / segs;
for (int n = 0; n < newSegments; n++)
{
_segmentPos[n + 1] = (seperation * (n + 1)) + transform.position;
AddJointPhysics(n + 1);
}
//for (int i = 0; i < _segments; i++)
//{
// //Set and update position of segments and update joints
//}
CharacterJoint end = target.gameObject.GetComponent <CharacterJoint>();
if (end == null)
{
end = target.gameObject.AddComponent <CharacterJoint>();
end.connectedBody = _joints[_joints.Count - 1].transform.GetComponent <Rigidbody>();
end.connectedBody.useGravity = false;
end.swingAxis = swingAxis;
end.lowTwistLimit = SetSoftJointLimitLimit(end.lowTwistLimit, lowTwistLimit);
end.highTwistLimit = SetSoftJointLimitLimit(end.highTwistLimit, highTwistLimit);
end.swing1Limit = SetSoftJointLimitLimit(end.swing1Limit, swing1Limit);
}
//target.parent = transform;
if (endRestrained)
{
end.GetComponent <Rigidbody>().isKinematic = true;
}
if (startRestrained)
{
transform.GetComponent <Rigidbody>().isKinematic = true;
}
// Rope = true, The rope now exists in the scene!
_rope = true;
}
void Awake()
{
tube = GetComponent <TubeRenderer>();
spring = GetComponent <SpringJoint>();
}
// Use this for initialization
void Awake()
{
m_tube = gameObject.AddComponent<TubeRenderer>();
}
//static float _ConstantSize;
public static void GeneratePositionData(LineData data, List <Vector3> positions, List <int> indices, List <Vector4> colors)
{
if (data.Points.Count < 2)
{
return;
}
List <TubeRenderer.TubeVertex> tubeVertices = new List <TubeRenderer.TubeVertex>(data.Points.Count);
for (int i = 0; i < data.Points.Count; i++)
{
TubeRenderer.AddPoint(data.Points[i].V3, data.rotations[i].Q, data.widths[i], data.colors[i].C, data.light[i], tubeVertices);
}
int additionalVertices = data.brushType == BrushType.Sphere ? 8 : 2;
int actualVertexCount = data.Points.Count + additionalVertices;
List <Vector3> meshVertices = new List <Vector3>(Enumerable.Repeat(default(Vector3), actualVertexCount));
List <Vector4> meshTangents = new List <Vector4>(Enumerable.Repeat(default(Vector4), actualVertexCount));
List <Vector3> meshNormals = new List <Vector3>(Enumerable.Repeat(default(Vector3), actualVertexCount));
List <Vector2> meshUvs = new List <Vector2>(Enumerable.Repeat(default(Vector2), actualVertexCount));
List <Color> meshColors = new List <Color>(Enumerable.Repeat(default(Color), actualVertexCount));
int[] meshIndices = null;
TubeRenderer.GenerateMesh(tubeVertices, 0, data.isFlat, data.isWeb, data.brushType, new Vector2(1, data.isFlat ? 0.3f : 1) * 0.5f,
meshVertices, meshTangents, meshNormals, meshUvs, meshColors, ref meshIndices, ref _LineLength);
_BrushType = (int)data.brushType;
_TaperAmountShape = data.taperShape ? 1 : 0;
_TaperAmountOpacity = data.taperOpacity ? 1 : 0;
_LineCount = data.multiLine ? 12f : 1.0f;
List <g2f> tristream = new List <g2f>(meshIndices.Length * 3);
for (int l = 0; l < 1; l++)
{
for (int i = 0; i < meshIndices.Length / 2; i++)
{
int i1 = meshIndices[i * 2 + 0];
int i2 = meshIndices[i * 2 + 1];
v2g v1 = vert(new Vertex()
{
vertex = meshVertices[i1], color = meshColors[i1], normal = meshNormals[i1], tangent = meshTangents[i1], uv = meshUvs[i1]
});
v2g v2 = vert(new Vertex()
{
vertex = meshVertices[i2], color = meshColors[i2], normal = meshNormals[i2], tangent = meshTangents[i2], uv = meshUvs[i2]
});
v2g[] op = new v2g[2]
{
v1, v2
};
v2g[] IN = new v2g[2]
{
v1, domain(op, new Vector2(0, l / _LineCount), _LineCount)
};
for (int u = 1; u <= 2; u++)
{
IN[0] = IN[1];
IN[1] = domain(op, new Vector2(((float)u) / 2, l / _LineCount), _LineCount);
geom(IN, tristream);
}
}
if (tristream.Count < 3)
{
continue;
}
int strip0 = positions.Count;
int strip1 = positions.Count + 1;
int strip2 = positions.Count + 2;
var pos = tristream[0].objPos;
data.transform.ApplyTo(ref pos);
positions.Add(pos);
colors.Add(tristream[0].color);
pos = tristream[1].objPos;
data.transform.ApplyTo(ref pos);
positions.Add(pos);
colors.Add(tristream[1].color);
bool flip = _BrushType != 0;
for (int i = 2; i < tristream.Count; i++)
{
if (flip)
{
indices.Add(strip2);
indices.Add(strip1);
indices.Add(strip0);
}
else
{
indices.Add(strip0);
indices.Add(strip1);
indices.Add(strip2);
}
flip = !flip;
strip0 = strip1;
strip1 = strip2;
strip2++;
pos = tristream[i].objPos;
data.transform.ApplyTo(ref pos);
positions.Add(pos);
colors.Add(tristream[i].color);
}
}
}
void Awake()
{
instance = this;
tube = GetComponent <TubeRenderer>();
}
GameObject MakeTree()
{
GameObject Root = new GameObject("Tree_GRP");
Root.name = "Root";
GameObject trunk = new GameObject();
trunk.transform.parent = Root.transform;
trunk.name = "Tree Trunk";
TubeRenderer tube = trunk.AddComponent <TubeRenderer>();
numberOfRows = Random.Range(rowNumberMin, rowNumberMax);
numberOfRowsPrivate = numberOfRows + bareTrunk + 1;
startRadiusPrivate = startRadius;
Vector3[] vecs = new Vector3[numberOfRowsPrivate];
float[] radius = new float[numberOfRowsPrivate];
for (int i = 0; i < numberOfRowsPrivate; i++)
{
startRadiusPrivate = startRadius * (1 - (i / numberOfRowsPrivate));
radius[i] = startRadiusPrivate;
if (i < 1)
{
vecs[i] = Vector3.zero;
radius[i] = startRadiusPrivate;
}
else
{
float xNoise = i * (mult * 0.001f) + Random.value * 1000;
float zNoise = i * (mult * 0.001f) + Random.value * 1000;
int posNegx = (int)(Mathf.Pow(-1, Random.Range(1, 2)));
int posNegZ = (int)(Mathf.Pow(-1, Random.Range(1, 2)));
heightIncRandomDivPrivate = Random.Range(heightIncRanDivMin, heightIncRanDivMax);
heightIncrementPrivate = heightIncrement * (1 + heightIncRandomDivPrivate);
currentTotalHeight += heightIncrementPrivate;
xCoord = ((Mathf.PerlinNoise(0, xNoise)) * xScale * posNegx) + xOffset;
yCoord = heightIncrementPrivate + (currentTotalHeight - heightIncrementPrivate);
zCoord = ((Mathf.PerlinNoise(0, zNoise)) * zScale * posNegZ) + zOffset;
vecs[i] = new Vector3(xCoord, yCoord, zCoord);
radius[i] = startRadiusPrivate;
if (i > (bareTrunk + 1))
{
GameObject row = MakeRow();
row.transform.parent = trunk.transform;
rowScaleMult = Random.Range(rowScaleMultMin, rowScaleMultMax);
rowScaleMultPrivate *= 1 - (i * rowScaleMult);
initialRowRotation = Random.Range(initialRowRotationMin, initialRowRotationMax);
rowRotationMult = Random.Range(rowRotationMultMin, rowRotationMultMax);
rowRotationMultCap = Random.Range(rowRotationMultCapMin, rowRotationMultCapMax);
rowRotationMultPrivate = initialRowRotation;
rowRotationMultPrivate += (i * rowRotationMult);
rowScaleMultCap = Random.Range(rowScaleMultCapMin, rowScaleMultCapmax);
for (int j = 0; j < row.transform.childCount; j++)
{
if (rowScaleMultPrivate < rowScaleMultCap)
{
rowScaleMultPrivate = rowScaleMultCap;
row.transform.GetChild(j).GetChild(0).localScale *= (1 + rowScaler) * rowScaleMultPrivate;
print(row.transform.GetChild(j).GetChild(0).name);
}
else
{
row.transform.GetChild(j).GetChild(0).localScale *= (1 + rowScaler) * rowScaleMultPrivate;
print(row.transform.GetChild(j).GetChild(0).name);
}
if (rowRotationMultPrivate < rowRotationMultCap)
{
Vector3 rowRotation = row.transform.GetChild(j).localEulerAngles;
rowRotation.z = rowRotationMultCap;
row.transform.GetChild(j).localEulerAngles = rowRotation;
print(row.transform.GetChild(j).name);
}
else
{
Vector3 rowRotation = row.transform.GetChild(j).localEulerAngles;
rowRotation.z = rowRotationMultPrivate;
row.transform.GetChild(j).localEulerAngles = rowRotation;
print(row.transform.GetChild(j).name);
}
}
row.transform.localPosition = vecs[i];
}
}
}
startRadiusPrivate = 1;
tube.SetPoints(vecs, radius, Color.white);
tube.material = trunkMaterial;
xCoord = 0;
yCoord = 0;
zCoord = 0;
rowScaleMultPrivate = 1;
rowRotationMultPrivate = 0;
currentTotalHeight = 0;
return(Root);
}
