public Color Evaluate(float time) { switch (mode) { default: case ColorGradientMode.Color: return(color); case ColorGradientMode.Gradient: return(gradient?.Evaluate(time) ?? new Color()); } }
public void SetMaxHealth(int health) { slider.maxValue = health; slider.value = health; fill.color = sliderColor.Evaluate(1f); }
private void Start() { scaleSlider = GetComponent <Slider>(); fillImage.color = gradient.Evaluate(0f); }
public void Refresh() { if (resolution != currentResolution) { CreateGrid(); } Quaternion q = Quaternion.Euler(rotation); Quaternion qInv = Quaternion.Inverse(q); Vector3 point00 = q * new Vector3(-0.5f, -0.5f) + offset; Vector3 point10 = q * new Vector3(0.5f, -0.5f) + offset; Vector3 point01 = q * new Vector3(-0.5f, 0.5f) + offset; Vector3 point11 = q * new Vector3(0.5f, 0.5f) + offset; NoiseMethod method = Noise.methods[(int)type][dimensions - 1]; float stepSize = 1f / resolution; float amplitude = damping ? strength / frequency : strength; for (int v = 0, y = 0; y <= resolution; y++) { Vector3 point0 = Vector3.Lerp(point00, point01, y * stepSize); Vector3 point1 = Vector3.Lerp(point10, point11, y * stepSize); for (int x = 0; x <= resolution; x++, v++) { Vector3 point = Vector3.Lerp(point0, point1, x * stepSize); NoiseSample sample = Noise.Sum(method, point, frequency, octaves, lacunarity, persistence); sample = sample * 0.5f; if (type != NoiseMethodType.Value) { sample = sample * 0.5f + 0.5f; } sample = type == NoiseMethodType.Value ? (sample - 0.5f) : (sample * 0.5f); if (coloringForStrength) { colors[v] = coloring.Evaluate(sample.value + 0.5f); sample *= amplitude; } else { sample *= amplitude; colors[v] = coloring.Evaluate(sample.value + 0.5f); } vertices[v].y = sample.value; sample.derivative = qInv * sample.derivative; if (analyticalDerivatives) { normals[v] = new Vector3(-sample.derivative.x, 1f, -sample.derivative.y).normalized; } colors[v] = coloring.Evaluate(vertices[v].y + 0.5f); } } mesh.vertices = vertices; mesh.colors = colors; if (!analyticalDerivatives) { CalculateNormals(); } mesh.normals = normals; }
void DrawLine() { height = 1.0f; radius = 0.09f; colorChangeSpeed = 0.1f; InitKernelIndex(); totalSegmentNum = (count * (maxSegmentNum + 1)); totalVertexNum = count * (numOfSides * maxSegmentNum + numOfSides); indices = new int[3 * 2 * numOfSides * maxSegmentNum]; Debug.Log("totalVertexNum : " + totalVertexNum); Debug.Log("totalSegmentNum : " + totalSegmentNum); Debug.Log("indexNum : " + indices.Length); vertices = new TorusVertex[totalVertexNum]; segments = new Segment[totalSegmentNum]; links = new Link[count]; initTargetPositions = new Vector3[count]; spherePositions = new Vector3[count * 2]; for (int i = 0; i < totalSegmentNum; i++) { segments[i] = new Segment(); } for (int i = 0; i < totalVertexNum; i++) { vertices[i] = new TorusVertex(); } for (int i = 0; i < count; i++) { var fromPos = arrivePoints[i]; var toPos = destPoints[i]; links[i].fromPos = fromPos; links[i].toPos = toPos; initTargetPositions[i] = toPos; spherePositions[i * 2] = fromPos; spherePositions[i * 2 + 1] = toPos; } SetIndices(); InitBuffer(); UpdateSegments(); colorsArr = new List <Color[]>(); for (int i = 0; i < gradientColors.Length; i++) { Gradient gradient = gradientColors[i]; var colors = new Color[100]; for (int j = 0; j < 100; j++) { colors[j] = gradient.Evaluate(j / 100f); } colorsArr.Add(colors); } }
public void SetColor(float value) { image.color = gradient.Evaluate(value); }
public Color GetColor(float tileHeight) { Color color = colorGradient.Evaluate(Mathf.InverseLerp(height.x, height.y, tileHeight)); return(color); }
IEnumerator AnimateTextComponent() { //Increase timer over Time to Evaluate Animation Curve and Color Gradient m_timer = 0; this.Text.gameObject.SetActive(true); //Time factor for Lerping float curveTimerX = 0; float curveTimerY = 0; float x; float y; //Time factor forLerpin float fontSizeCurveAnim = 0; //Animation Length float animationTime = m_animDuration; //change Icon Alpha with Text Alpahe var tempColor = IconLeft.isActiveAndEnabled ? IconLeft.color : IconRight.color; var backgroundColorCache = Background.color; //as long as timer is not bigger than the Animation Length while (m_timer < animationTime) { //Evaluate Timer with the Curve curveTimerX = m_animCurveX.Evaluate(m_timer); curveTimerY = m_animCurveY.Evaluate(m_timer); //if amount == 0 no Size Animation if (m_amount != 0) { fontSizeCurveAnim = m_fontSizeAnimCurve.Evaluate(m_timer); Text.fontSize = (int)Mathf.Lerp(this.m_fontSize, m_amount, fontSizeCurveAnim); } this.Text.color = m_colorGradient.Evaluate(m_timer); tempColor.a = Text.color.a; backgroundColorCache.a = Text.color.a; if (IconLeft.isActiveAndEnabled) { IconLeft.color = tempColor; } else { IconRight.color = tempColor; } if (Background.isActiveAndEnabled) { //Text.color; Background.color = backgroundColorCache; } //Based on the Transform Z-Axis, disable if less than 0 bool isInView = m_rectTransform.position.z < 0; this.gameObject.SetActive(!isInView); if (m_stack && m_onScreen == false) { //m_startPosition = Vector3.Lerp(m_startPosition, m_currentPosition, m_timer / animationTime); } //ternary position = If(onScreen ==false)cam.WorldToScreenPoint(startPosition) else startPosition this.transform.position = m_onScreen == false?m_cam.WorldToScreenPoint(m_startPosition) : m_startPosition; //Lerp the Text GameObject in localSpace x = Mathf.Lerp(0, m_animationDirection.x, curveTimerX); y = Mathf.Lerp(0, m_animationDirection.y, curveTimerY); this.SctBox.localPosition = new Vector3(x, y, 0); m_timer += Time.deltaTime; yield return(null); } //disable Text Component to avoid weird jump behaviour this.Text.gameObject.SetActive(false); this.IconRight.enabled = false; this.IconLeft.enabled = false; Background.enabled = false; this.SctBox.localPosition = Vector3.zero; //deactivate this Object -> back to Pool this.gameObject.SetActive(false); }
// Start Coroutine of reading the points from the XYZ file and creating the meshes IEnumerator loadXYZ(string dPath) { // Read file numPoints = File.ReadAllLines(Application.dataPath + dPath).Length; StreamReader sr = new StreamReader(Application.dataPath + dPath); points = new Vector3[numPoints]; colors = new Color[numPoints]; minValue = new Vector3(); for (int i = 0; i < numPoints; i++) { string[] buffer = sr.ReadLine().Split(','); if (!invertYZ) { points[i] = new Vector3(float.Parse(buffer[0]) * scale, float.Parse(buffer[1]) * scale, float.Parse(buffer[2]) * scale); } else { points[i] = new Vector3(float.Parse(buffer[0]) * scale, float.Parse(buffer[2]) * scale, float.Parse(buffer[1]) * scale); } // Test enum for technique to colour points // Apply default point colour if (colourPointsBy == cpb.Default) { colors[i] = defaultPointColour; } // Colour points by RGB values if (colourPointsBy == cpb.RGB) { if (buffer.Length >= 5) { colors[i] = new Color(int.Parse(buffer[3]) / 255.0f, int.Parse(buffer[4]) / 255.0f, int.Parse(buffer[5]) / 255.0f); } else { colors[i] = defaultPointColour; } } // TO DO - Automate calculation of minHeight and maxHeight // Colour points by Height else if (colourPointsBy == cpb.Height) { if (!invertYZ) { localDiff = float.Parse(buffer[1]) - minHeight; } else { localDiff = float.Parse(buffer[2]) - minHeight; } colors[i] = colourGradient.Evaluate(localDiff / heightDiff); } //TO DO - Automate calculation of minIntensity and maxIntensity // Colour points by intensity else if (colourPointsBy == cpb.Intensity) { relativeDiff = float.Parse(buffer[6]) - minIntensity; colors[i] = colourGradient.Evaluate(relativeDiff / intensityDiff); } // Relocate points near the origin if (relocateToOrigin == true) { calculateMin(points[i]); } // Processing GUI progress = i * 1.0f / (numPoints - 1) * 1.0f; if (i % Mathf.FloorToInt(numPoints / 20) == 0) { guiText = i.ToString() + " out of " + numPoints.ToString() + " loaded"; yield return(null); } } // Instantiate Point Groups numPointGroups = Mathf.CeilToInt(numPoints * 1.0f / limitPoints * 1.0f); pointCloud = new GameObject(filename); for (int i = 0; i < numPointGroups - 1; i++) { InstantiateMesh(i, limitPoints); if (i % 10 == 0) { guiText = i.ToString() + " out of " + numPointGroups.ToString() + " PointGroups loaded"; yield return(null); } } InstantiateMesh(numPointGroups - 1, numPoints - (numPointGroups - 1) * limitPoints); //Store PointCloud UnityEditor.PrefabUtility.SaveAsPrefabAsset(pointCloud, "Assets/Resources/PointCloudMeshes/" + filename + ".prefab"); loaded = true; }
public void SetMaxHealth(float health) { slider.maxValue = health; slider.value = health; fill.color = gradient.Evaluate(1f); }
public void ApplyLocalWindZoneColor(float windForce01) { localWindZoneMaterial.color = localWindZoneGradient.Evaluate(windForce01); }
protected Color getColor() { return(color.Evaluate(curve.Evaluate(timeKeeper))); }
void SetStressBarColor(float value) { rageImageBar.color = gradient.Evaluate(rageSlider.normalizedValue); }
public static Color Eval(float val) { return(InfluenceGradient.Evaluate(Mathf.Sign(val) * Mathf.Pow(Mathf.Abs(val), .5f) / 2 + .5f)); }
public string GetChargeValueText() { int numShots = Mathf.FloorToInt(this._charge / JuicePerDischarge); int maxShots = Mathf.FloorToInt(this.capacity / JuicePerDischarge); float num = numShots / maxShots; //return Language.main.GetFormat<string, float, int, float>("BatteryCharge", ColorUtility.ToHtmlStringRGBA(gradient.Evaluate(num)), num, numShots, maxShots); return(Language.main.GetFormat <string, float, int, int>("<color=#{0}>{1,4}u ({2}/{3})</color>", ColorUtility.ToHtmlStringRGBA(gradient.Evaluate(num)), Mathf.Floor(this.charge), numShots, maxShots)); }
// Update is called once per frame void Update() { float key = image.fillAmount; image.color = gradient.Evaluate(key); }
private void Update() { float deltaTime = Time.deltaTime; FractalPart rootPart = parts[0][0]; rootPart.spinAngle += rootPart.spinVelocity * deltaTime; rootPart.worldRotation = mul(transform.rotation, mul(rootPart.rotation, quaternion.RotateY(rootPart.spinAngle))); rootPart.worldPosition = transform.position; parts[0][0] = rootPart; float objectScale = transform.lossyScale.x; float3x3 r = float3x3(rootPart.worldRotation) * objectScale; matrices[0][0] = float3x4(r.c0, r.c1, r.c2, rootPart.worldPosition); float scale = objectScale; JobHandle jobHandle = default; for (int li = 1; li < parts.Length; li++) { scale *= 0.5f; jobHandle = new UpdateFractalLevelJob { deltaTime = deltaTime, scale = scale, parents = parts[li - 1], parts = parts[li], matrices = matrices[li] }.ScheduleParallel(parts[li].Length, 5, jobHandle); } jobHandle.Complete(); Bounds bounds = new Bounds(rootPart.worldPosition, 3f * objectScale * Vector3.one); int leafIndex = matricesBuffers.Length - 1; for (int i = 0; i < matricesBuffers.Length; i++) { ComputeBuffer buffer = matricesBuffers[i]; Mesh instanceMesh; Color colorA, colorB; if (i == leafIndex) { colorA = leafColorA; colorB = leafColorB; instanceMesh = leafMesh; } else { float gradientInterpolator = i / (matricesBuffers.Length - 1f); colorA = gradientA.Evaluate(gradientInterpolator); colorB = gradientB.Evaluate(gradientInterpolator); instanceMesh = mesh; } propertyBlock.SetColor(colorAID, colorA); propertyBlock.SetColor(colorBID, colorB); buffer.SetData(matrices[i]); propertyBlock.SetBuffer(matricesID, buffer); propertyBlock.SetVector(sequenceNumbersID, sequenceNumbers[i]); Graphics.DrawMeshInstancedProcedural(instanceMesh, 0, material, bounds, buffer.count, propertyBlock); } }
private void Update() { spriteRenderer.color = gradient.Evaluate(Mathf.PingPong(Time.time * speedMultiplier, 1f)); }
public IEnumerator ColorHeight(Gradient gradient, float min = 0.0f, float max = 1.0f) { //Color vertices according to height //Values are normalized to enable a min max Color[] vertex_colors = new Color[mesh_deforming.vertices.Length]; for (int y = 0; y < mesh_size.y; y++) { //yield return null; for (int x = 0; x < mesh_size.x; x++) { int i = (int)(y * mesh_size.x) + x; Triangle current_triangle = triangles[i]; //float lerp = Mathf.InverseLerp(minmax_Y.x, minmax_Y.y, current_triangle.value); float lerp = Mathf.InverseLerp(min, 1.0f, current_triangle.value); vertex_colors[current_triangle.i1] = vertex_colors[current_triangle.i2] = vertex_colors[current_triangle.i3] = gradient.Evaluate(lerp); mesh_deforming.colors = vertex_colors; } } mesh_deforming.colors = vertex_colors; Debug.Log("Applied color height."); yield break; }
void UpdateSlider() { fill.color = gradient.Evaluate(1 / ((slider.maxValue - slider.minValue) / slider.value)); }
private void Update() { renderer.material.color = colorGradient.Evaluate(value); value = Mathf.Lerp(value, 0f, lerpVelocity * Time.deltaTime); }
private void GenerateMesh() { DeleteGrid(); var verticesList = new List <Vector3>(); var trianglesList = new List <int>(); var colorList = new List <Color>(); float minTerrainHeight = 0; float maxTerrainHeight = 0; #region New int scale = 0; for (int depth = 0; depth < _mapSize - 1; depth++) { for (int width = 0; width < _mapSize - 1; width++) { for (int z = depth; z < depth + 2; z++) { for (int x = width; x < width + 2; x++) { float y = _heightMap[x, z]; verticesList.Add(new Vector3(x, y, z)); // For gradients min and max value if (y > maxTerrainHeight) { maxTerrainHeight = y; } if (y < minTerrainHeight) { minTerrainHeight = y; } } } trianglesList.Add(0 + scale); trianglesList.Add(2 + scale); trianglesList.Add(3 + scale); trianglesList.Add(0 + scale); trianglesList.Add(3 + scale); trianglesList.Add(1 + scale); scale += 4; } } #endregion foreach (Vector3 vertex in verticesList) { float height = Mathf.InverseLerp(minTerrainHeight, maxTerrainHeight, vertex.y); colorList.Add(_gradient.Evaluate(height)); } #region Old // for (int z = 0, i = 0; z <= _mapSize; z++) { // for (int x = 0; x <= _mapSize; x++) { // verticesList[i] = new Vector3(x, _heightMap[x, z], z); // i++; // } // } // // int vert = 0; // int tris = 0; // for (int z = 0; z < _mapSize; z++) { // for (int i = 0; i < _mapSize; i++) { // trianglesList[tris + 0] = vert + 0; // trianglesList[tris + 1] = vert + _mapSize + 1; // trianglesList[tris + 2] = vert + 1; // trianglesList[tris + 3] = vert + 1; // trianglesList[tris + 4] = vert + _mapSize + 1; // trianglesList[tris + 5] = vert + _mapSize + 2; // // vert++; // tris += 6; // } // vert++; // } #endregion _mesh.Clear(); _mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32; _mesh.vertices = verticesList.ToArray(); _mesh.triangles = trianglesList.ToArray(); _mesh.colors = colorList.ToArray(); _mesh.RecalculateNormals(); _mesh.RecalculateBounds(); _mesh.RecalculateTangents(); _parent = Instantiate(_parentPrefab); }
private void UpdateColor() { m_Renderer.GetPropertyBlock(m_MPB); m_MPB.SetColor("_Color", m_Gradient.Evaluate(m_Energy)); m_Renderer.SetPropertyBlock(m_MPB); }
public void SetHealth(int health) { slider.value = health; fill.color = gradient.Evaluate(slider.normalizedValue); }
void MakeSomeNoise() { perlin1 = new Vector2(perlinStartX, perlinStartY); var perlin2 = new Vector2(Random.Range(0f, 100f), Random.Range(0f, 100f)); var perlinOffset = Random.value; Mesh sm = originalMesh; Mesh lm = new Mesh(); Vector3[] vertices = sm.vertices; Vector3[] normals = sm.normals; int[] tris = sm.triangles; Vector3[] originalVertices = null; if (originalMesh != null) { originalVertices = originalMesh.vertices; } Color[] colors = new Color[vertices.Length]; for (int i = 0; i < vertices.Length; i++) { float xCoord = perlin1.x + vertices[i].x * scale; float yCoord = perlin1.y + vertices[i].z * scale; var y = (Mathf.PerlinNoise(xCoord, yCoord) - 0.5f); vertices[i].y = (y * power); if (originalVertices != null) { vertices[i].y += originalVertices[i].y; if (flatBottom && originalVertices[i].y < 0) { vertices[i].y = originalVertices[i].y; } } colors[i] = gradient.Evaluate(y + perlinOffset * Mathf.PerlinNoise(perlin2.x, perlin2.y)); } for (int i = 0; i < normals.Length; i++) { if (normals[i].y < 0.1f) { colors[i] = sideColor; } } lm.vertices = vertices; lm.triangles = tris; lm.colors = colors; lm.RecalculateBounds(); lm.RecalculateNormals(); MeshFilter mf = GetComponent <MeshFilter>(); mf.mesh = lm; MeshCollider mc = GetComponent <MeshCollider>(); if (mc != null) { mc.sharedMesh = lm; } }
private static MeshDraft TerrainDraft(Vector3 terrainSize, float cellSize, Vector2 noiseOffset, float noiseScale, Gradient gradient, float uvScale) //change in this script { int xSegments = Mathf.FloorToInt(terrainSize.x / cellSize); int zSegments = Mathf.FloorToInt(terrainSize.z / cellSize); float xStep = terrainSize.x / xSegments; float zStep = terrainSize.z / zSegments; int vertexCount = 6 * xSegments * zSegments; MeshDraft draft = new MeshDraft { name = "Terrain", vertices = new List <Vector3>(vertexCount), triangles = new List <int>(vertexCount), normals = new List <Vector3>(vertexCount), colors = new List <Color>(vertexCount), uv = new List <Vector2>(vertexCount)//addition in this script }; for (int i = 0; i < vertexCount; i++) { draft.vertices.Add(Vector3.zero); draft.triangles.Add(0); draft.normals.Add(Vector3.zero); draft.colors.Add(Color.black); draft.uv.Add(Vector2.zero);//addition in this script } for (int x = 0; x < xSegments; x++) { for (int z = 0; z < zSegments; z++) { int index0 = 6 * (x + z * xSegments); int index1 = index0 + 1; int index2 = index0 + 2; int index3 = index0 + 3; int index4 = index0 + 4; int index5 = index0 + 5; float height00 = GetHeight(x + 0, z + 0, xSegments, zSegments, noiseOffset, noiseScale); float height01 = GetHeight(x + 0, z + 1, xSegments, zSegments, noiseOffset, noiseScale); float height10 = GetHeight(x + 1, z + 0, xSegments, zSegments, noiseOffset, noiseScale); float height11 = GetHeight(x + 1, z + 1, xSegments, zSegments, noiseOffset, noiseScale); Vector3 vertex00 = new Vector3((x + 0) * xStep, height00 * terrainSize.y, (z + 0) * zStep); Vector3 vertex01 = new Vector3((x + 0) * xStep, height01 * terrainSize.y, (z + 1) * zStep); Vector3 vertex10 = new Vector3((x + 1) * xStep, height10 * terrainSize.y, (z + 0) * zStep); Vector3 vertex11 = new Vector3((x + 1) * xStep, height11 * terrainSize.y, (z + 1) * zStep); draft.vertices[index0] = vertex00; draft.vertices[index1] = vertex01; draft.vertices[index2] = vertex11; draft.vertices[index3] = vertex00; draft.vertices[index4] = vertex11; draft.vertices[index5] = vertex10; draft.colors[index0] = gradient.Evaluate(height00); draft.colors[index1] = gradient.Evaluate(height01); draft.colors[index2] = gradient.Evaluate(height11); draft.colors[index3] = gradient.Evaluate(height00); draft.colors[index4] = gradient.Evaluate(height11); draft.colors[index5] = gradient.Evaluate(height10); Vector3 normal000111 = Vector3.Cross(vertex01 - vertex00, vertex11 - vertex00).normalized; Vector3 normal001011 = Vector3.Cross(vertex11 - vertex00, vertex10 - vertex00).normalized; draft.normals[index0] = normal000111; draft.normals[index1] = normal000111; draft.normals[index2] = normal000111; draft.normals[index3] = normal001011; draft.normals[index4] = normal001011; draft.normals[index5] = normal001011; draft.triangles[index0] = index0; draft.triangles[index1] = index1; draft.triangles[index2] = index2; draft.triangles[index3] = index3; draft.triangles[index4] = index4; draft.triangles[index5] = index5; //addition in this script float xUV0 = ((float)x / (float)xSegments) * uvScale; float zUV0 = ((float)z / (float)zSegments) * uvScale; float xUV1 = ((float)(x + 1) / (float)xSegments) * uvScale; float zUV1 = ((float)(z + 1) / (float)zSegments) * uvScale; draft.uv[index0] = new Vector2(xUV0, zUV0); draft.uv[index1] = new Vector2(xUV0, zUV1); draft.uv[index2] = new Vector2(xUV1, zUV1); draft.uv[index3] = new Vector2(xUV0, zUV0); draft.uv[index4] = new Vector2(xUV1, zUV1); draft.uv[index5] = new Vector2(xUV1, zUV0); } } return(draft); }
/// <summary> Draw a bezier from output to input in grid coordinates </summary> public void DrawNoodle(Gradient gradient, NoodlePath path, NoodleStroke stroke, float thickness, List <Vector2> gridPoints) { // convert grid points to window points for (int i = 0; i < gridPoints.Count; ++i) { gridPoints[i] = GridToWindowPosition(gridPoints[i]); } Handles.color = gradient.Evaluate(0f); int length = gridPoints.Count; switch (path) { case NoodlePath.Curvy: Vector2 outputTangent = Vector2.right; for (int i = 0; i < length - 1; i++) { Vector2 inputTangent; // Cached most variables that repeat themselves here to avoid so many indexer calls :p Vector2 point_a = gridPoints[i]; Vector2 point_b = gridPoints[i + 1]; float dist_ab = Vector2.Distance(point_a, point_b); if (i == 0) { outputTangent = zoom * dist_ab * 0.01f * Vector2.right; } if (i < length - 2) { Vector2 point_c = gridPoints[i + 2]; Vector2 ab = (point_b - point_a).normalized; Vector2 cb = (point_b - point_c).normalized; Vector2 ac = (point_c - point_a).normalized; Vector2 p = (ab + cb) * 0.5f; float tangentLength = (dist_ab + Vector2.Distance(point_b, point_c)) * 0.005f * zoom; float side = ((ac.x * (point_b.y - point_a.y)) - (ac.y * (point_b.x - point_a.x))); p = tangentLength * Mathf.Sign(side) * new Vector2(-p.y, p.x); inputTangent = p; } else { inputTangent = zoom * dist_ab * 0.01f * Vector2.left; } // Calculates the tangents for the bezier's curves. float zoomCoef = 50 / zoom; Vector2 tangent_a = point_a + outputTangent * zoomCoef; Vector2 tangent_b = point_b + inputTangent * zoomCoef; // Hover effect. int division = Mathf.RoundToInt(.2f * dist_ab) + 3; // Coloring and bezier drawing. int draw = 0; Vector2 bezierPrevious = point_a; for (int j = 1; j <= division; ++j) { if (stroke == NoodleStroke.Dashed) { draw++; if (draw >= 2) { draw = -2; } if (draw < 0) { continue; } if (draw == 0) { bezierPrevious = CalculateBezierPoint(point_a, tangent_a, tangent_b, point_b, (j - 1f) / (float)division); } } if (i == length - 2) { Handles.color = gradient.Evaluate((j + 1f) / division); } Vector2 bezierNext = CalculateBezierPoint(point_a, tangent_a, tangent_b, point_b, j / (float)division); DrawAAPolyLineNonAlloc(thickness, bezierPrevious, bezierNext); bezierPrevious = bezierNext; } outputTangent = -inputTangent; } break; case NoodlePath.Straight: for (int i = 0; i < length - 1; i++) { Vector2 point_a = gridPoints[i]; Vector2 point_b = gridPoints[i + 1]; // Draws the line with the coloring. Vector2 prev_point = point_a; // Approximately one segment per 5 pixels int segments = (int)Vector2.Distance(point_a, point_b) / 5; segments = Math.Max(segments, 1); int draw = 0; for (int j = 0; j <= segments; j++) { draw++; float t = j / (float)segments; Vector2 lerp = Vector2.Lerp(point_a, point_b, t); if (draw > 0) { if (i == length - 2) { Handles.color = gradient.Evaluate(t); } DrawAAPolyLineNonAlloc(thickness, prev_point, lerp); } prev_point = lerp; if (stroke == NoodleStroke.Dashed && draw >= 2) { draw = -2; } } } break; case NoodlePath.Angled: for (int i = 0; i < length - 1; i++) { if (i == length - 1) { continue; // Skip last index } if (gridPoints[i].x <= gridPoints[i + 1].x - (50 / zoom)) { float midpoint = (gridPoints[i].x + gridPoints[i + 1].x) * 0.5f; Vector2 start_1 = gridPoints[i]; Vector2 end_1 = gridPoints[i + 1]; start_1.x = midpoint; end_1.x = midpoint; if (i == length - 2) { DrawAAPolyLineNonAlloc(thickness, gridPoints[i], start_1); Handles.color = gradient.Evaluate(0.5f); DrawAAPolyLineNonAlloc(thickness, start_1, end_1); Handles.color = gradient.Evaluate(1f); DrawAAPolyLineNonAlloc(thickness, end_1, gridPoints[i + 1]); } else { DrawAAPolyLineNonAlloc(thickness, gridPoints[i], start_1); DrawAAPolyLineNonAlloc(thickness, start_1, end_1); DrawAAPolyLineNonAlloc(thickness, end_1, gridPoints[i + 1]); } } else { float midpoint = (gridPoints[i].y + gridPoints[i + 1].y) * 0.5f; Vector2 start_1 = gridPoints[i]; Vector2 end_1 = gridPoints[i + 1]; start_1.x += 25 / zoom; end_1.x -= 25 / zoom; Vector2 start_2 = start_1; Vector2 end_2 = end_1; start_2.y = midpoint; end_2.y = midpoint; if (i == length - 2) { DrawAAPolyLineNonAlloc(thickness, gridPoints[i], start_1); Handles.color = gradient.Evaluate(0.25f); DrawAAPolyLineNonAlloc(thickness, start_1, start_2); Handles.color = gradient.Evaluate(0.5f); DrawAAPolyLineNonAlloc(thickness, start_2, end_2); Handles.color = gradient.Evaluate(0.75f); DrawAAPolyLineNonAlloc(thickness, end_2, end_1); Handles.color = gradient.Evaluate(1f); DrawAAPolyLineNonAlloc(thickness, end_1, gridPoints[i + 1]); } else { DrawAAPolyLineNonAlloc(thickness, gridPoints[i], start_1); DrawAAPolyLineNonAlloc(thickness, start_1, start_2); DrawAAPolyLineNonAlloc(thickness, start_2, end_2); DrawAAPolyLineNonAlloc(thickness, end_2, end_1); DrawAAPolyLineNonAlloc(thickness, end_1, gridPoints[i + 1]); } } } break; case NoodlePath.ShaderLab: Vector2 start = gridPoints[0]; Vector2 end = gridPoints[length - 1]; //Modify first and last point in array so we can loop trough them nicely. gridPoints[0] = gridPoints[0] + Vector2.right * (20 / zoom); gridPoints[length - 1] = gridPoints[length - 1] + Vector2.left * (20 / zoom); //Draw first vertical lines going out from nodes Handles.color = gradient.Evaluate(0f); DrawAAPolyLineNonAlloc(thickness, start, gridPoints[0]); Handles.color = gradient.Evaluate(1f); DrawAAPolyLineNonAlloc(thickness, end, gridPoints[length - 1]); for (int i = 0; i < length - 1; i++) { Vector2 point_a = gridPoints[i]; Vector2 point_b = gridPoints[i + 1]; // Draws the line with the coloring. Vector2 prev_point = point_a; // Approximately one segment per 5 pixels int segments = (int)Vector2.Distance(point_a, point_b) / 5; segments = Math.Max(segments, 1); int draw = 0; for (int j = 0; j <= segments; j++) { draw++; float t = j / (float)segments; Vector2 lerp = Vector2.Lerp(point_a, point_b, t); if (draw > 0) { if (i == length - 2) { Handles.color = gradient.Evaluate(t); } DrawAAPolyLineNonAlloc(thickness, prev_point, lerp); } prev_point = lerp; if (stroke == NoodleStroke.Dashed && draw >= 2) { draw = -2; } } } gridPoints[0] = start; gridPoints[length - 1] = end; break; } }
public void SetHealthBarColor(float percentage) { HealthBarImage.color = gradient.Evaluate(percentage); }
/// <summary> /// Converts an array of colors into an approximate Gradient using a max of 8 color keys and 8 alpha keys /// </summary> /// <param name="colors"></param> /// <param name="gradient"></param> /// <param name="approxColors"></param> /// <param name="approxAlpha"></param> /// <returns>Error data specifying deviation from ideal case</returns> public static ErrorData ApproximateColorArrayAsGradient(Color[] colors, Gradient gradient, List <GradientColorKey> approxColors, List <GradientAlphaKey> approxAlpha) { approxAlpha.Clear(); approxColors.Clear(); float invLength = 1f / (colors.Length - 1); // Init the lists for (int i = 0; i < colors.Length - 1; i++) { // Add first alpha value that deviates from front if (colors[i].a != colors[i + 1].a) { var t = i * invLength; approxAlpha.Add(new GradientAlphaKey(colors[i].a, t)); break; } } for (int i = 0; i < colors.Length - 1; i++) { // Add first color value that deviates from front if (colors[i].r != colors[i + 1].r || colors[i].g != colors[i + 1].g || colors[i].b != colors[i + 1].b) { var t = i * invLength; approxColors.Add(new GradientColorKey(colors[i], t)); break; } } for (int i = colors.Length - 1; i > 0; i--) { // Add first alpha value that deviates from back if (colors[i].a != colors[i - 1].a) { var t = i * invLength; approxAlpha.Add(new GradientAlphaKey(colors[i].a, t)); break; } } for (int i = colors.Length - 1; i > 0; i--) { // Add first color value that deviates from back if (colors[i].r != colors[i - 1].r || colors[i].g != colors[i - 1].g || colors[i].b != colors[i - 1].b) { var t = i * invLength; approxColors.Add(new GradientColorKey(colors[i], t)); break; } } gradient.SetKeys(approxColors.ToArray(), approxAlpha.ToArray()); int iters = 8; while (iters-- > 0) { float maxColorDistance = 0f, maxAlphaDistance = 0f; int maxColorDistanceIndex = -1, maxAlphaDistanceIndex = -1; for (int i = 0; i < colors.Length; i++) { var gradientColor = gradient.Evaluate(i * invLength); var alphaDistance = Mathf.Abs(colors[i].a - gradientColor.a); var colorDistance = ColorRGBSqrDistance(colors[i], gradientColor); if (alphaDistance > maxAlphaDistance && alphaDistance > 1e-3f) { maxAlphaDistance = alphaDistance; maxAlphaDistanceIndex = i; } if (colorDistance > maxColorDistance && colorDistance > 1e-3f) { maxColorDistance = colorDistance; maxColorDistanceIndex = i; } } // Break if no deviations found if (maxColorDistanceIndex == -1 && maxAlphaDistanceIndex == -1) { break; } // Insert new keys if (maxAlphaDistanceIndex != -1) { var newKeyLocation = maxAlphaDistanceIndex * invLength; var newAlpha = colors[maxAlphaDistanceIndex].a; for (int i = 0; i < approxAlpha.Count; i++) { if (newKeyLocation > approxAlpha[i].time) { approxAlpha.Insert(i + 1, new GradientAlphaKey(newAlpha, newKeyLocation)); break; } } } if (maxColorDistanceIndex != -1) { var newKeyLocation = maxColorDistanceIndex * invLength; var newColor = colors[maxColorDistanceIndex]; for (int i = 0; i < approxColors.Count; i++) { if (newKeyLocation > approxColors[i].time) { approxColors.Insert(i + 1, new GradientColorKey(newColor, newKeyLocation)); break; } } } // Update gradient gradient.SetKeys(approxColors.ToArray(), approxAlpha.ToArray()); // Break if we have used maximum allowed Color and Alpha keys if (approxAlpha.Count == 8 || approxColors.Count == 8) { break; } } // Calculate error values var totalErr = 0f; var maxErr = 0f; for (int i = 0; i < colors.Length; i++) { var approx = gradient.Evaluate(i / (float)(colors.Length - 1)); var error = Mathf.Sqrt(ColorRGBASqrDistance(approx, colors[i])); totalErr += error; maxErr = Mathf.Max(maxErr, error); } var avg = totalErr / colors.Length; var totalDeviation = 0f; for (int i = 0; i < colors.Length; i++) { var approx = gradient.Evaluate(i / (float)(colors.Length - 1)); var error = Mathf.Sqrt(ColorRGBASqrDistance(approx, colors[i])); var deviation = (error - avg) * (error - avg); totalDeviation += deviation; } var stdDev = Mathf.Sqrt(totalDeviation / colors.Length); return(new ErrorData(avg, stdDev, maxErr)); }
public Color GetColor(float inputValue) { inputValue = Mathf.Clamp(inputValue, minInputValue, maxInputValue); inputValue = (inputValue - minInputValue) / Mathf.Max(maxInputValue - minInputValue, .00001f); return(gradient.Evaluate(inputValue)); }