/*public InfoPool CreateNewIvy() * { * return CreateNewIvy(this.selectedPreset); * }*/ public InfoPool CreateNewIvy() { IvyParameters parameters = new IvyParameters(); parameters.CopyFrom(ivyParametersGUI); return(CreateNewIvy(parameters)); }
public Vector2 GetLastUV(IvyParameters ivyParameters) { Vector2 res = new Vector2(totalLength * ivyParameters.uvScale.y + ivyParameters.uvOffset.y, 0.5f * ivyParameters.uvScale.x + ivyParameters.uvOffset.x); return(res); }
private void CalculateLeafRotation(IvyParameters ivyParameters) { Vector3 left, forward; if (!ivyParameters.globalOrientation) { forward = this.lpForward; left = this.left; } else { forward = ivyParameters.globalRotation; left = Vector3.Normalize(Vector3.Cross(ivyParameters.globalRotation, this.lpUpward)); } leafRotation = Quaternion.LookRotation(this.lpUpward, forward); leafRotation = Quaternion.AngleAxis(ivyParameters.rotation.x, left) * Quaternion.AngleAxis(ivyParameters.rotation.y, lpUpward) * Quaternion.AngleAxis(ivyParameters.rotation.z, forward) * leafRotation; leafRotation = Quaternion.AngleAxis(Random.Range(-ivyParameters.randomRotation.x, ivyParameters.randomRotation.x), left) * Quaternion.AngleAxis(Random.Range(-ivyParameters.randomRotation.y, ivyParameters.randomRotation.y), lpUpward) * Quaternion.AngleAxis(Random.Range(-ivyParameters.randomRotation.z, ivyParameters.randomRotation.z), forward) * leafRotation; }
public void CreateVertices(IvyParameters ivyParameters, RTMeshData leafMeshData, GameObject ivyGO) { Vector3 vertex = Vector3.zero; Vector3 normal = Vector3.zero; Vector2 uv = Vector2.zero; Color vertexColor = Color.black; Quaternion ivyGOInverseRotation = Quaternion.Inverse(ivyGO.transform.rotation); leafCenter = ivyGO.transform.InverseTransformPoint(point); for (int v = 0; v < leafMeshData.vertices.Length; v++) { Vector3 offset = left * ivyParameters.offset.x + this.lpUpward * ivyParameters.offset.y + this.lpForward * ivyParameters.offset.z; vertex = leafRotation * leafMeshData.vertices[v] * leafScale + point + offset; vertex = vertex - ivyGO.transform.position; vertex = ivyGOInverseRotation * vertex; normal = leafRotation * leafMeshData.normals[v]; normal = ivyGOInverseRotation * normal; uv = leafMeshData.uv[v]; vertexColor = leafMeshData.colors[v]; this.vertices[v] = new RTVertexData(vertex, normal, uv, Vector2.zero, vertexColor); } }
public Vector3 GetFirstVector(RTBranchPoint rtBranchPoint, RTBranchContainer rtBranchContainer, RTIvyContainer rtIvyContainer, IvyParameters ivyParameters, Vector3 axis) { Vector3 firstVector = Vector3.zero; if (rtBranchContainer.branchNumber == 0 && rtBranchPoint.index == 0) { if (!ivyParameters.halfgeom) { firstVector = rtIvyContainer.firstVertexVector; } else { firstVector = Quaternion.AngleAxis(90f, axis) * rtIvyContainer.firstVertexVector; } } else { if (!ivyParameters.halfgeom) { firstVector = Vector3.Normalize(Vector3.ProjectOnPlane(rtBranchPoint.grabVector, axis)); } else { firstVector = Quaternion.AngleAxis(90f, axis) * Vector3.Normalize(Vector3.ProjectOnPlane(rtBranchPoint.grabVector, axis)); } } return(firstVector); }
public void CalculateVerticesLoop(IvyParameters ivyParameters, RTIvyContainer rtIvyContainer, GameObject ivyGO, Vector3 firstVector, Vector3 axis, float radius) { this.firstVector = firstVector; this.axis = axis; this.radius = radius; CalculateVerticesLoop(ivyParameters, rtIvyContainer, ivyGO); }
public void CopyFrom(IvyParameters copyFrom) { this.stepSize = copyFrom.stepSize; this.branchProvability = copyFrom.branchProvability; this.maxBranchs = copyFrom.maxBranchs; this.layerMask = copyFrom.layerMask; this.minDistanceToSurface = copyFrom.minDistanceToSurface; this.maxDistanceToSurface = copyFrom.maxDistanceToSurface; this.DTSFrequency = copyFrom.DTSFrequency; this.DTSRandomness = copyFrom.DTSRandomness; this.directionFrequency = copyFrom.directionFrequency; this.directionAmplitude = copyFrom.directionAmplitude; this.directionRandomness = copyFrom.directionRandomness; this.gravity = copyFrom.gravity; this.grabProvabilityOnFall = copyFrom.grabProvabilityOnFall; this.stiffness = copyFrom.stiffness; this.optAngleBias = copyFrom.optAngleBias; this.leaveEvery = copyFrom.leaveEvery; this.randomLeaveEvery = copyFrom.randomLeaveEvery; this.halfgeom = copyFrom.halfgeom; this.sides = copyFrom.sides; this.minRadius = copyFrom.minRadius; this.maxRadius = copyFrom.maxRadius; this.radiusVarFreq = copyFrom.radiusVarFreq; this.radiusVarOffset = copyFrom.radiusVarOffset; this.tipInfluence = copyFrom.tipInfluence; this.uvScale = copyFrom.uvScale; this.uvOffset = copyFrom.uvOffset; this.minScale = copyFrom.minScale; this.maxScale = copyFrom.maxScale; this.globalOrientation = copyFrom.globalOrientation; this.globalRotation = copyFrom.globalRotation; this.rotation = copyFrom.rotation; this.randomRotation = copyFrom.randomRotation; this.offset = copyFrom.offset; this.LMUVPadding = copyFrom.LMUVPadding; this.generateBranches = copyFrom.generateBranches; this.generateLeaves = copyFrom.generateLeaves; this.generateLightmapUVs = copyFrom.generateLightmapUVs; this.branchesMaterial = copyFrom.branchesMaterial; this.leavesPrefabs = new GameObject[copyFrom.leavesPrefabs.Length]; for (int i = 0; i < copyFrom.leavesPrefabs.Length; i++) { this.leavesPrefabs[i] = copyFrom.leavesPrefabs[i]; } this.leavesProb = new float[copyFrom.leavesProb.Length]; for (int i = 0; i < copyFrom.leavesProb.Length; i++) { this.leavesProb[i] = copyFrom.leavesProb[i]; } }
public InfoPool CreateNewIvy(IvyPreset selectedPreset) { this.selectedPreset = selectedPreset; IvyParameters parameters = new IvyParameters(); parameters.CopyFrom(selectedPreset); return(CreateNewIvy(parameters)); }
public void CalculateVerticesLoop(IvyParameters ivyParameters, RTIvyContainer rtIvyContainer, GameObject ivyGO) { float angle = 0f; if (!ivyParameters.halfgeom) { angle = Mathf.Rad2Deg * 2 * Mathf.PI / ivyParameters.sides; } else { angle = Mathf.Rad2Deg * 2 * Mathf.PI / ivyParameters.sides / 2; } Vector3 vertex = Vector3.zero; Vector3 normal = Vector3.zero; Vector2 uv = Vector2.zero; Quaternion quat = Quaternion.identity; Vector3 direction = Vector3.zero; Quaternion inverseIvyGORotation = Quaternion.Inverse(ivyGO.transform.rotation); for (int i = 0; i < ivyParameters.sides + 1; i++) { quat = Quaternion.AngleAxis(angle * i, axis); direction = quat * firstVector; if (ivyParameters.halfgeom && ivyParameters.sides == 1) { normal = -grabVector; } else { normal = direction; } normal = inverseIvyGORotation * normal; vertex = direction * radius + point; vertex -= ivyGO.transform.position; vertex = inverseIvyGORotation * vertex; uv = new Vector2(length * ivyParameters.uvScale.y + ivyParameters.uvOffset.y - ivyParameters.stepSize, 1f / ivyParameters.sides * i * ivyParameters.uvScale.x + ivyParameters.uvOffset.x); verticesLoop[i] = new RTVertexData(vertex, normal, uv, Vector2.zero, Color.black); } }
public void Initialize(IvyContainer ivyContainer, IvyParameters ivyParameters, GameObject ivyGO, RTMeshData[] leavesMeshesByChosenLeaf, Vector3 firstVertexVector) { lastBranchNumberAssigned = 0; this.branches = new List <RTBranchContainer>(ivyContainer.branches.Count); for (int i = 0; i < ivyContainer.branches.Count; i++) { RTBranchContainer rtBranch = new RTBranchContainer(ivyContainer.branches[i], ivyParameters, this, ivyGO, leavesMeshesByChosenLeaf); this.branches.Add(rtBranch); } this.firstVertexVector = firstVertexVector; }
protected override void Init(IvyContainer ivyContainer, IvyParameters ivyParameters) { base.Init(ivyContainer, ivyParameters); rtIvyGrowth = new RuntimeIvyGrowth(); rtIvyGrowth.Init(rtIvyContainer, ivyParameters, gameObject, leavesMeshesByChosenLeaf, GetMaxNumPoints(), GetMaxNumLeaves(), GetMaxNumVerticesPerLeaf()); for (int i = 0; i < 10; i++) { rtIvyGrowth.Step(); } this.currentLifetime = this.growthParameters.lifetime; }
public bool IsEqualTo(IvyParameters compareTo) { bool isEqual; isEqual = stepSize == compareTo.stepSize && branchProvability == compareTo.branchProvability && maxBranchs == compareTo.maxBranchs && layerMask == compareTo.layerMask && minDistanceToSurface == compareTo.minDistanceToSurface && maxDistanceToSurface == compareTo.maxDistanceToSurface && DTSFrequency == compareTo.DTSFrequency && DTSRandomness == compareTo.DTSRandomness && directionFrequency == compareTo.directionFrequency && directionAmplitude == compareTo.directionAmplitude && directionRandomness == compareTo.directionRandomness && gravity == compareTo.gravity && grabProvabilityOnFall == compareTo.grabProvabilityOnFall && stiffness == compareTo.stiffness && optAngleBias == compareTo.optAngleBias && leaveEvery == compareTo.leaveEvery && randomLeaveEvery == compareTo.randomLeaveEvery && buffer32Bits == compareTo.buffer32Bits && halfgeom == compareTo.halfgeom && sides == compareTo.sides && minRadius == compareTo.minRadius && maxRadius == compareTo.maxRadius && radiusVarFreq == compareTo.radiusVarFreq && radiusVarOffset == compareTo.radiusVarOffset && tipInfluence == compareTo.tipInfluence && uvScale == compareTo.uvScale && uvOffset == compareTo.uvOffset && minScale == compareTo.minScale && maxScale == compareTo.maxScale && globalOrientation == compareTo.globalOrientation && globalRotation == compareTo.globalRotation && rotation == compareTo.rotation && randomRotation == compareTo.randomRotation && offset == compareTo.offset && LMUVPadding == compareTo.LMUVPadding && branchesMaterial == compareTo.branchesMaterial && leavesPrefabs.SequenceEqual(compareTo.leavesPrefabs) && leavesProb.SequenceEqual(compareTo.leavesProb) && generateBranches == compareTo.generateBranches && generateLeaves == compareTo.generateLeaves && generateLightmapUVs == compareTo.generateLightmapUVs; return(isEqual); }
public RTLeafPoint(LeafPoint leafPoint, IvyParameters ivyParameters) { this.point = leafPoint.point; this.lpLength = leafPoint.lpLength; this.left = leafPoint.left; this.lpForward = leafPoint.lpForward; this.lpUpward = leafPoint.lpUpward; this.initSegmentIdx = leafPoint.initSegmentIdx; this.endSegmentIdx = leafPoint.endSegmentIdx; this.chosenLeave = leafPoint.chosenLeave; this.vertices = leafPoint.verticesLeaves.ToArray(); this.leafCenter = leafPoint.leafCenter; this.leafRotation = leafPoint.leafRotation; this.leafScale = leafPoint.leafScale; CalculateLeafRotation(ivyParameters); }
public InfoPool CreateNewIvy(IvyParameters ivyParameters) { infoPool = ScriptableObject.CreateInstance <InfoPool>(); infoPool.ivyContainer = ScriptableObject.CreateInstance <IvyContainer>(); infoPool.ivyContainer.branches = new List <BranchContainer>(); infoPool.ivyParameters = ivyParameters; infoPool.ivyParameters.UV2IslesSizes = new Dictionary <int, Vector2>(); infoPool.growth = ScriptableObject.CreateInstance <EditorIvyGrowth>(); infoPool.growth.infoPool = infoPool; infoPool.meshBuilder = ScriptableObject.CreateInstance <EditorMeshBuilder>(); infoPool.meshBuilder.infoPool = infoPool; infoPool.meshBuilder.ivyMesh = new Mesh(); RealIvyWindow.realIvyProToolsWindow.infoPool = infoPool; return(infoPool); }
public void InitIvyEditor(RuntimeGrowthParameters growthParameters, IvyContainer ivyContainer, IvyParameters ivyParameters) { this.growthParameters = growthParameters; Init(ivyContainer, ivyParameters); }
public void PreInit(IvyParameters ivyParameters) { this.verticesLoop = new RTVertexData[ivyParameters.sides + 1]; }
public IvyParameters(IvyParameters copyFrom) { CopyFrom(copyFrom); }
public void SetValues(Vector3 point, float lpLength, Vector3 lpForward, Vector3 lpUpward, int chosenLeave, RTBranchPoint initSegment, RTBranchPoint endSegment, float leafScale, IvyParameters ivyParameters) { this.point = point; this.lpLength = lpLength; this.lpForward = lpForward; this.lpUpward = lpUpward; this.chosenLeave = chosenLeave; this.initSegmentIdx = initSegment.index; this.endSegmentIdx = endSegment.index; this.leafScale = leafScale; this.left = Vector3.Cross(lpForward, lpUpward).normalized; CalculateLeafRotation(ivyParameters); }
public void InitializeMeshBuilder(IvyParameters ivyParameters, RTIvyContainer ivyContainer, RTIvyContainer bakedIvyContainer, GameObject ivyGO, Mesh bakedMesh, MeshRenderer meshRenderer, MeshFilter meshFilter, int numBranches, Mesh processedMesh, float growSpeed, MeshRenderer mrProcessedMesh, int backtrackingPoints, int[] submeshByChoseLeaf, RTMeshData[] leavesMeshesByChosenLeaf, Material[] materials) { this.ivyParameters = ivyParameters; this.rtIvyContainer = ivyContainer; this.rtBakedIvyContainer = bakedIvyContainer; this.ivyGO = ivyGO; this.meshRenderer = meshRenderer; this.meshFilter = meshFilter; this.processedMesh = processedMesh; this.processedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt16; this.mrProcessedMesh = mrProcessedMesh; this.submeshByChoseLeaf = submeshByChoseLeaf; this.leavesMeshesByChosenLeaf = leavesMeshesByChosenLeaf; activeBranches = new List <RTBranchContainer>(); this.fromTo = new int[2]; this.vectors = new Vector3[2]; this.growthSpeed = growSpeed; this.backtrackingPoints = backtrackingPoints; this.submeshCount = meshRenderer.sharedMaterials.Length; vertCountsPerBranch = new int[numBranches]; lastTriangleIndexPerBranch = new int[numBranches]; vertCountLeavesPerBranch = new int[numBranches]; processedVerticesIndicesPerBranch = new List <List <int> >(numBranches); processedBranchesVerticesIndicesPerBranch = new List <List <int> >(numBranches); for (int i = 0; i < numBranches; i++) { processedVerticesIndicesPerBranch.Add(new List <int>()); processedBranchesVerticesIndicesPerBranch.Add(new List <int>()); } this.vertCount = 0; ivyMesh = new Mesh(); ivyMesh.subMeshCount = submeshCount; ivyMesh.name = Constants.IVY_MESH_NAME; meshFilter.mesh = ivyMesh; ivyGO.GetComponent <MeshRenderer>().sharedMaterials = materials; mrProcessedMesh.sharedMaterials = materials; leavesDataInitialized = true; ivyGoPosition = ivyGO.transform.position; ivyGoRotation = ivyGO.transform.rotation; ivyGoInverseRotation = Quaternion.Inverse(ivyGO.transform.rotation); zeroVector3 = Vector3.zero; zeroVector2 = Vector2.zero; blackColor = Color.black; }
public override void InitIvy(RuntimeGrowthParameters growthParameters, IvyContainer ivyContainer, IvyParameters ivyParameters) { this.growthParameters = growthParameters; Init(null, ivyParameters); InitMeshBuilder(); AddFirstBranch(); }
protected override void Init(IvyContainer ivyContainer, IvyParameters ivyParameters) { base.Init(ivyContainer, ivyParameters); CalculateLifetime(); }
public void CopyFrom(IvyParameters copyFrom) { this.stepSize = copyFrom.stepSize; this.branchProvability = copyFrom.branchProvability; this.maxBranchs = copyFrom.maxBranchs; this.layerMask = copyFrom.layerMask; this.minDistanceToSurface = copyFrom.minDistanceToSurface; this.maxDistanceToSurface = copyFrom.maxDistanceToSurface; this.DTSFrequency = copyFrom.DTSFrequency; this.DTSRandomness = copyFrom.DTSRandomness; this.directionFrequency = copyFrom.directionFrequency; this.directionAmplitude = copyFrom.directionAmplitude; this.directionRandomness = copyFrom.directionRandomness; this.gravityX = copyFrom.gravity.x; this.gravityY = copyFrom.gravity.y; this.gravityZ = copyFrom.gravity.z; this.grabProvabilityOnFall = copyFrom.grabProvabilityOnFall; this.stiffness = copyFrom.stiffness; this.optAngleBias = copyFrom.optAngleBias; this.leaveEvery = copyFrom.leaveEvery; this.randomLeaveEvery = copyFrom.randomLeaveEvery; this.buffer32Bits = copyFrom.buffer32Bits; this.halfgeom = copyFrom.halfgeom; this.sides = copyFrom.sides; this.minRadius = copyFrom.minRadius; this.maxRadius = copyFrom.maxRadius; this.radiusVarFreq = copyFrom.radiusVarFreq; this.radiusVarOffset = copyFrom.radiusVarOffset; this.tipInfluence = copyFrom.tipInfluence; this.uvScaleX = copyFrom.uvScale.x; this.uvScaleY = copyFrom.uvScale.y; this.uvOffsetX = copyFrom.uvOffset.x; this.uvOffsetY = copyFrom.uvOffset.y; this.minScale = copyFrom.minScale; this.maxScale = copyFrom.maxScale; this.globalOrientation = copyFrom.globalOrientation; this.globalRotationX = copyFrom.globalRotation.x; this.globalRotationY = copyFrom.globalRotation.y; this.globalRotationZ = copyFrom.globalRotation.z; this.rotationX = copyFrom.rotation.x; this.rotationY = copyFrom.rotation.y; this.rotationZ = copyFrom.rotation.z; this.randomRotationX = copyFrom.randomRotation.x; this.randomRotationY = copyFrom.randomRotation.y; this.randomRotationZ = copyFrom.randomRotation.z; this.randomRotationX = copyFrom.randomRotation.x; this.randomRotationY = copyFrom.randomRotation.y; this.randomRotationZ = copyFrom.randomRotation.z; this.offsetX = copyFrom.offset.x; this.offsetY = copyFrom.offset.y; this.offsetZ = copyFrom.offset.z; this.LMUVPadding = copyFrom.LMUVPadding; this.generateBranches = copyFrom.generateBranches; this.generateLeaves = copyFrom.generateLeaves; this.generateLightmapUVs = copyFrom.generateLightmapUVs; this.branchesMaterial = copyFrom.branchesMaterial; this.leavesProb.Clear(); for (int i = 0; i < copyFrom.leavesProb.Length; i++) { this.leavesProb.Add(copyFrom.leavesProb[i]); } this.leavesPrefabs.Clear(); for (int i = 0; i < copyFrom.leavesPrefabs.Length; i++) { this.leavesPrefabs.Add(copyFrom.leavesPrefabs[i]); } //this.UV2IslesSizes = copyFrom.UV2IslesSizes; }
public void Init(RTIvyContainer ivyContainer, IvyParameters ivyParameters, GameObject ivyGO, RTMeshData[] leavesMeshesByChosenLeaf, int numPoints, int numLeaves, int maxNumVerticesPerLeaf) { this.rtIvyContainer = ivyContainer; this.ivyParameters = ivyParameters; this.ivyGO = ivyGO; this.leavesMeshesByChosenLeaf = leavesMeshesByChosenLeaf; this.numPoints = numPoints; this.numLeaves = numLeaves; this.maxNumVerticesPerLeaf = maxNumVerticesPerLeaf; this.branchPointsPool = new RTBranchPoint[numPoints]; this.branchPointPoolIndex = 0; for (int i = 0; i < numPoints; i++) { RTBranchPoint branchPoint = new RTBranchPoint(); branchPoint.PreInit(ivyParameters); branchPointsPool[i] = branchPoint; } this.leavesPool = new RTLeafPoint[numLeaves]; this.leavesPoolIndex = 0; for (int i = 0; i < numLeaves; i++) { RTLeafPoint leafPoint = new RTLeafPoint(); leafPoint.PreInit(maxNumVerticesPerLeaf); leavesPool[i] = leafPoint; } this.branchesPool = new RTBranchContainer[ivyParameters.maxBranchs]; for (int i = 0; i < ivyParameters.maxBranchs; i++) { this.branchesPool[i] = new RTBranchContainer(numPoints, numLeaves); } Random.InitState(System.Environment.TickCount); RTBranchContainer firstBranch = GetNextBranchContainer(); ivyContainer.AddBranch(firstBranch); RTBranchPoint nextRTBranchPoint = GetNextFreeBranchPoint(); nextRTBranchPoint.SetValues(ivyGO.transform.position, -ivyGO.transform.up, false, 0); firstBranch.AddBranchPoint(nextRTBranchPoint, ivyParameters.stepSize); CalculateVerticesLastPoint(firstBranch); //Vector3 axis = GetLoopAxis(nextRTBranchPoint, firstBranch, rtIvyContainer, ivyGO); //Vector3 firstVector = GetFirstVector(nextRTBranchPoint, firstBranch, rtIvyContainer, ivyParameters, axis); //nextRTBranchPoint.CalculateCenterLoop(ivyGO); //nextRTBranchPoint.CalculateVerticesLoop(ivyParameters, rtIvyContainer, ivyGO, firstVector, axis); ivyContainer.branches[0].growDirection = Quaternion.AngleAxis(Random.value * 360f, ivyGO.transform.up) * ivyGO.transform.forward; ivyContainer.firstVertexVector = ivyContainer.branches[0].growDirection; ivyContainer.branches[0].randomizeHeight = Random.Range(4f, 8f); CalculateNewHeight(ivyContainer.branches[0]); ivyContainer.branches[0].branchSense = ChooseBranchSense(); randomstate = Random.state; }
public abstract void InitIvy(RuntimeGrowthParameters growthParameters, IvyContainer ivyContainer, IvyParameters ivyParameters);
public void InitializeRuntime(IvyParameters ivyParameters) { this.verticesLoop = new List <RTVertexData>(ivyParameters.sides + 1); }
/* public void InitIvy(RuntimeGrowthParameters growthParameters, IvyContainer ivyContainer, * IvyParameters ivyParameters) * { * this.growthParameters = growthParameters; * Init(ivyContainer, ivyParameters); * AddFirstBranch(); * } */ protected virtual void Init(IvyContainer ivyContainer, IvyParameters ivyParameters) { this.rtIvyContainer = new RTIvyContainer(); this.ivyParameters = new IvyParameters(); this.ivyParameters.CopyFrom(ivyParameters); CreateLeavesDict(); if (ivyContainer != null) { this.rtIvyContainer.Initialize(ivyContainer, ivyParameters, gameObject, leavesMeshesByChosenLeaf, ivyContainer.firstVertexVector); } else { this.rtIvyContainer.Initialize(); } SetUpMaxBranches(ivyContainer); activeBakedBranches = new List <RTBranchContainer>(maxBranches); activeBuildingBranches = new List <RTBranchContainer>(maxBranches); rtBuildingIvyContainer = new RTIvyContainer(); Vector3 firstVertexVector = ivyContainer == null?CalculateFirstVertexVector() : ivyContainer.firstVertexVector; rtBuildingIvyContainer.Initialize(firstVertexVector); lastIdxActiveBranch = -1; leafLengthCorrrectionFactor = 1; int submeshCount = ivyParameters.leavesPrefabs.Length + 1; this.processedMesh = new Mesh(); processedMesh.subMeshCount = submeshCount; mfProcessedMesh.sharedMesh = processedMesh; this.refreshProcessedMesh = false; this.backtrackingPoints = GetBacktrackingPoints(); if (this.bakedMesh == null) { this.bakedMesh = new Mesh(); this.bakedMesh.subMeshCount = submeshCount; } /* meshBuilder = new RTBakedMeshBuilder(rtIvyContainer, gameObject); * meshBuilder.InitializeMeshBuilder(ivyParameters, rtBuildingIvyContainer, rtIvyContainer, * gameObject, bakedMesh, meshRenderer, meshFilter, maxBranches, * processedMesh, growthParameters.growthSpeed, mrProcessedMesh, * backtrackingPoints, submeshByChoseLeaf, leavesMeshesDict, leavesMaterials.ToArray()); */ lastCopiedIndexPerBranch = new List <int>(maxBranches); leavesToCopyMesh = new List <LeafPoint>(50); srcPoints = new List <Vector3>(maxBranches); dstPoints = new List <Vector3>(maxBranches); growingFactorPerBranch = new List <float>(maxBranches); srcTotalLengthPerBranch = new List <float>(maxBranches); dstTotalLengthPerBranch = new List <float>(maxBranches); lengthPerBranch = new List <float>(maxBranches); for (int i = 0; i < maxBranches; i++) { srcPoints.Add(Vector3.zero); dstPoints.Add(Vector3.zero); growingFactorPerBranch.Add(0f); srcTotalLengthPerBranch.Add(0f); dstTotalLengthPerBranch.Add(0f); lastCopiedIndexPerBranch.Add(-1); lengthPerBranch.Add(0f); int branchPointsSize = GetMaxNumPoints(); int numLeaves = GetMaxNumLeaves(); RTBranchContainer branchContainer = new RTBranchContainer(branchPointsSize, numLeaves); activeBuildingBranches.Add(branchContainer); } }
public RTBranchContainer(BranchContainer branchContainer, IvyParameters ivyParameters, RTIvyContainer rtIvyContainer, GameObject ivyGO, RTMeshData[] leavesMeshesByChosenLeaf) { this.totalLength = branchContainer.totalLenght; this.growDirection = branchContainer.growDirection; this.randomizeHeight = branchContainer.randomizeHeight; this.heightVar = branchContainer.heightVar; this.newHeight = branchContainer.newHeight; this.heightParameter = branchContainer.heightParameter; this.deltaHeight = branchContainer.deltaHeight; this.currentHeight = branchContainer.currentHeight; this.branchSense = branchContainer.branchSense; this.falling = branchContainer.falling; this.rotationOnFallIteration = branchContainer.rotationOnFallIteration; this.branchNumber = branchContainer.branchNumber; this.branchPoints = new List <RTBranchPoint>(branchContainer.branchPoints.Count); for (int i = 0; i < branchContainer.branchPoints.Count; i++) { RTBranchPoint rtBranchPoint = new RTBranchPoint(branchContainer.branchPoints[i], this); rtBranchPoint.CalculateCenterLoop(ivyGO); rtBranchPoint.PreInit(ivyParameters); rtBranchPoint.CalculateVerticesLoop(ivyParameters, rtIvyContainer, ivyGO); this.branchPoints.Add(rtBranchPoint); } branchContainer.PrepareRTLeavesDict(); if (ivyParameters.generateLeaves) { this.leavesOrderedByInitSegment = new RTLeafPoint[branchPoints.Count][]; for (int i = 0; i < branchPoints.Count; i++) { List <LeafPoint> leavesToBake = branchContainer.dictRTLeavesByInitSegment[i]; int numLeaves = 0; if (leavesToBake != null) { numLeaves = leavesToBake.Count; } this.leavesOrderedByInitSegment[i] = new RTLeafPoint[numLeaves]; for (int j = 0; j < numLeaves; j++) { RTLeafPoint rtLeafPoint = new RTLeafPoint(leavesToBake[j], ivyParameters); RTMeshData leafMeshData = leavesMeshesByChosenLeaf[rtLeafPoint.chosenLeave]; rtLeafPoint.CreateVertices(ivyParameters, leafMeshData, ivyGO); this.leavesOrderedByInitSegment[i][j] = rtLeafPoint; } } } }
public void CreateVertices(IvyParameters ivyParameters, RTMeshData leafMeshData, GameObject ivyGO) { Vector3 left, forward; Quaternion quat; //Aquí cálculos de orientación en función de las opciones de rotación if (!ivyParameters.globalOrientation) { forward = lpForward; left = this.left; //left = Vector3.Cross(currentLeaf.lpForward, currentLeaf.lpUpward); } else { forward = ivyParameters.globalRotation; left = Vector3.Normalize(Vector3.Cross(ivyParameters.globalRotation, this.lpUpward)); } //Y aplicamos la rotación quat = Quaternion.LookRotation(this.lpUpward, forward); quat = Quaternion.AngleAxis(ivyParameters.rotation.x, left) * Quaternion.AngleAxis(ivyParameters.rotation.y, this.lpUpward) * Quaternion.AngleAxis(ivyParameters.rotation.z, forward) * quat; quat = Quaternion.AngleAxis(Random.Range(-ivyParameters.randomRotation.x, ivyParameters.randomRotation.x), left) * Quaternion.AngleAxis(Random.Range(-ivyParameters.randomRotation.y, ivyParameters.randomRotation.y), this.lpUpward) * Quaternion.AngleAxis(Random.Range(-ivyParameters.randomRotation.z, ivyParameters.randomRotation.z), forward) * quat; quat = this.forwarRot * quat; //Aquí la escala, que es facilita, incluyendo el tip influence float scale = Random.Range(ivyParameters.minScale, ivyParameters.maxScale); //scale *= Mathf.InverseLerp(infoPool.ivyContainer.branches[b].totalLenght, infoPool.ivyContainer.branches[b].totalLenght - infoPool.ivyParameters.tipInfluence, currentLeaf.lpLength); /*******************/ this.leafRotation = quat; //currentLeaf.dstScale = scale; /*******************/ this.leafCenter = this.point - ivyGO.transform.position; this.leafCenter = Quaternion.Inverse(ivyGO.transform.rotation) * this.leafCenter; if (this.verticesLeaves == null) { this.verticesLeaves = new List <RTVertexData>(4); } //this.verticesLeaves.Clear(); Vector3 vertex = Vector3.zero; Vector3 normal = Vector3.zero; Vector2 uv = Vector2.zero; Color vertexColor = Color.black; Quaternion ivyGOInverseRotation = Quaternion.Inverse(ivyGO.transform.rotation); for (int v = 0; v < leafMeshData.vertices.Length; v++) { Vector3 offset = left * ivyParameters.offset.x + this.lpUpward * ivyParameters.offset.y + this.lpForward * ivyParameters.offset.z; vertex = quat * leafMeshData.vertices[v] * scale + leafCenter + offset; normal = quat * leafMeshData.normals[v]; normal = ivyGOInverseRotation * normal; uv = leafMeshData.uv[v]; vertexColor = leafMeshData.colors[v]; RTVertexData vertexData = new RTVertexData(vertex, normal, uv, Vector2.zero, vertexColor); this.verticesLeaves.Add(vertexData); } }