private void Update()
{
if (!Initialized)
{
return;
}
bubbleTransform.position = Vector3.Lerp(bubbleTransform.position, initialPosition, bubbleReturnSpeed * Time.deltaTime);
bubbleVelocity = Vector3.Lerp(bubbleVelocity, Vector3.zero, Time.deltaTime);
for (int i = 0; i < fingertips.Length; i++)
{
Fingertip fingertip = fingertips[i];
fingertip.Block.SetColor("_Color", fingertip.Color);
fingertip.Renderer.SetPropertyBlock(fingertip.Block);
fingertip.PrevPoint = fingertip.Point;
fingertip.Point = fingers[i].position;
fingertip.Velocity = (fingertip.Point - fingertip.PrevPoint);
fingertip.Renderer.transform.localScale = Vector3.one * touchBubbleCurve.Evaluate(Time.time - fingertip.TimeIntersectedBubble);
if (Vector3.Distance(fingertip.Point, bubbleTransform.position) < bubble.Radius)
{
bubbleVelocity += fingertip.Velocity;
}
fingertips[i] = fingertip;
}
bubbleTransform.position += (bubbleVelocity * fingerForce);
controller.RadiusMultiplier = bubbleVelocity.magnitude * fingerForce;
}
private void Update()
{
if (!Initialized)
{
return;
}
for (int i = 0; i < chunks.Length; i++)
{
chunkHeat[i] = Mathf.Lerp(chunkHeat[i], 0f, Time.deltaTime * heatDecreaseSpeed);
LavaChunk chunk = chunks[i];
chunk.Heat = chunkHeat[i];
Vector4 hdrColor = Vector4.zero;
hdrColor.x = baseColor.r;
hdrColor.y = baseColor.g;
hdrColor.z = baseColor.b;
Color color = heatColor.Evaluate(chunkHeat[i]);
hdrColor.x += color.r * 6;
hdrColor.y += color.g * 6;
hdrColor.z += color.b * 6;
chunkPropertyBocks[i].SetColor("_EmissiveColor", hdrColor);
chunk.Renderer.SetPropertyBlock(chunkPropertyBocks[i]);
}
for (int i = 0; i < fingertips.Length; i++)
{
Fingertip fingertip = fingertips[i];
fingertip.Emission.enabled = (fingertip.Heat > 0.25f);
fingertip.Heat = Mathf.Lerp(fingertip.Heat, 0f, Time.deltaTime * heatDecreaseSpeed);
fingertips[i] = fingertip;
}
for (int i = 0; i < lavaBubbles.Length; i++)
{
if (lavaBubbles[i].gameObject.activeSelf)
{
if (!lavaBubbles[i].enabled)
{
lavaBubbles[i].gameObject.SetActive(false);
}
}
else
{
if (Random.value > spawnOdds)
{
if (!Physics.CheckSphere(lavaBubbles[i].transform.position, bubbleCheckRadius, chunkLayer))
{
lavaBubbles[i].gameObject.SetActive(true);
}
}
}
}
lavaScrollPos += scrollSpeed * Time.deltaTime;
lavaMat.SetTextureOffset("_MainTex", lavaScrollPos);
}
protected override void FixedUpdate()
{
if (!Initialized)
{
return;
}
base.FixedUpdate();
for (int i = 0; i < fingers.Length; i++)
{
Transform finger = fingers[i];
Fingertip fingertip = fingertips[i];
if (!finger.gameObject.activeSelf)
{
continue;
}
// If the finger is below the surface, ignore it
float distToSurface = Vector3.Distance(finger.position, transform.position);
if (distToSurface < SurfaceRadius)
{
continue;
}
for (int chunkIndex = 0; chunkIndex < chunks.Length; chunkIndex++)
{
LavaChunk chunk = chunks[chunkIndex];
Vector3 fingerPos = finger.position;
Vector3 closestPos = chunk.Collider.ClosestPoint(fingerPos);
float dist = Vector3.Distance(fingerPos, closestPos);
if (dist > fingerForceDist)
{
continue;
}
// Add heat and force to the chunk
Vector3 force = (closestPos - fingerPos).normalized * fingerPushForce;
chunk.RigidBody.AddForceAtPosition(force, fingerPos, ForceMode.Force);
chunkHeat[chunkIndex] = Mathf.Lerp(chunkHeat[chunkIndex], 1f, Time.fixedDeltaTime * heatIncreaseSpeed);
chunkHeat[i] = Mathf.Lerp(chunkHeat[i], 1f, Time.fixedDeltaTime * heatIncreaseSpeed * chunks[i].SubmergedAmount);
// Add heat to the fingertip
fingertip.Heat = Mathf.Lerp(fingertip.Heat, 1f, Time.fixedDeltaTime * heatIncreaseSpeed);
}
fingertips[i] = fingertip;
}
}
private void OnExitBubble(int innerBubbleIndex)
{
Fingertip f = fingertips[innerBubbleIndex];
f.Audio.pitch = UnityEngine.Random.Range(0.8f, 1.2f);
f.Audio.clip = enterBubbleClips[UnityEngine.Random.Range(0, enterBubbleClips.Length)];
f.Audio.Play();
f.TimeIntersectedBubble = Time.time;
fingertips[innerBubbleIndex] = f;
for (int i = 0; i < bubbleTouchParticles.Length; i++)
{
if (!bubbleTouchParticles[i].gameObject.activeSelf)
{
bubbleTouchParticles[i].transform.position = f.Point;
bubbleTouchParticles[i].gameObject.SetActive(true);
break;
}
}
}
public override void Initialize(Vector3 surfacePosition)
{
base.Initialize(surfacePosition);
initialPosition = bubbleTransform.position;
fingertips = new Fingertip[fingers.Length];
for (int i = 0; i < fingers.Length; i++)
{
Fingertip fingertip = new Fingertip();
fingertip.Block = new MaterialPropertyBlock();
fingertip.Renderer = fingers[i].GetComponentInChildren <MeshRenderer>();
fingertip.Color = bubble.InnerBubbles[i].Color;
fingertip.Audio = fingers[i].GetComponentInChildren <AudioSource>();
fingertips[i] = fingertip;
}
bubble.OnEnterBubble += OnEnterBubble;
bubble.OnExitBubble += OnExitBubble;
}
public override void Initialize(Vector3 surfacePosition)
{
base.Initialize(surfacePosition);
// Set up our bubbles
for (int i = 0; i < lavaBubbles.Length; i++)
{
Vector3 randomPos = Random.onUnitSphere * bubbleDistance;
lavaBubbles[i].transform.up = randomPos.normalized;
lavaBubbles[i].transform.Rotate(-90f, 0f, 0f, Space.Self);
lavaBubbles[i].transform.localPosition = randomPos;
lavaBubbles[i].gameObject.SetActive(false);
}
chunkHeat = new float[chunks.Length];
chunkPropertyBocks = new MaterialPropertyBlock[chunks.Length];
for (int i = 0; i < chunks.Length; i++)
{
LavaChunk chunk = chunks[i];
chunk.RigidBody.AddForce(UnityEngine.Random.insideUnitSphere * initialImpulseForce, ForceMode.Force);
chunkPropertyBocks[i] = new MaterialPropertyBlock();
chunk.OnCollision += OnCollision;
}
fingertips = new Fingertip[fingers.Length];
for (int i = 0; i < fingertips.Length; i++)
{
Fingertip ft = new Fingertip();
ft.Heat = 0;
ft.Block = new MaterialPropertyBlock();
//ft.Rigidbody = fingers[i].GetComponentInChildren<Rigidbody>();
ft.Renderer = fingers[i].GetComponentInChildren <MeshRenderer>();
ft.Particles = fingers[i].GetComponentInChildren <ParticleSystem>();
ft.Emission = ft.Particles.emission;
ft.Emission.enabled = false;
fingertips[i] = ft;
}
}
private void PrepareForUpdate()
{
// Gather all the info we can only get in the main thread
cameraPos = CameraCache.Main.transform.position;
cameraUp = CameraCache.Main.transform.up;
cameraFwd = CameraCache.Main.transform.forward;
cameraRht = CameraCache.Main.transform.right;
totalDistortionTarget = 0;
for (int i = 0; i < fingers.Length; i++)
{
Transform finger = fingers[i];
Force force = forces[i];
force.PrevPoint = force.Point;
force.Radius = fingertipRadius;
if (!finger.gameObject.activeSelf)
{
force.Active = false;
}
else
{
if (!force.Active)
{
force.Velocity = Vector3.zero;
}
else
{
force.Velocity = force.Point - finger.position;
}
force.Point = finger.position;
force.Active = true;
if (force.IsIntersecting)
{
totalDistortionTarget += force.Velocity.magnitude;
}
}
if (force.IsIntersecting)
{
if (!force.WasIntersecting)
{
force.WasIntersecting = true;
fingertips[i].PingAudio.Play();
}
}
else
{
force.WasIntersecting = false;
}
forces[i] = force;
}
if (totalDistortion < totalDistortionTarget)
{
totalDistortion = totalDistortionTarget;
}
else
{
totalDistortion = Mathf.Lerp(totalDistortion, totalDistortionTarget, Time.deltaTime * distortionFadeSpeed);
}
for (int i = 0; i < fingertips.Length; i++)
{
Force force = forces[i];
Fingertip fingertip = fingertips[i];
float velocity = force.Velocity.magnitude * fingertipVelocityColor;
fingertip.Color = Color.Lerp(fingertip.Color, fingertipColor.Evaluate(velocity), Time.deltaTime);
fingertip.Block.SetColor("_Color", fingertip.Color);
fingertip.Mesh.SetPropertyBlock(fingertip.Block);
fingertip.Trail.SetPropertyBlock(fingertip.Block);
fingertips[i] = fingertip;
}
time = Time.time;
deltaTime = Time.time - timeLastUpdated;
timeLastUpdated = time;
}
public override void Initialize(Vector3 surfacePosition)
{
base.Initialize(surfacePosition);
ISceneTransitionService transitionService;
if (MixedRealityServiceRegistry.TryGetService <ISceneTransitionService>(out transitionService))
{
transitionService.OnTransitionStarted += OnTransitionStarted;
}
tileScale = 1f / numColumns;
tileOffsets = new Vector2[numTiles];
int tileNum = 0;
for (int row = 0; row < numRows; row++)
{
for (int column = 0; column < numColumns; column++)
{
Vector2 uv = Vector2.zero;
uv.x = tileScale * column;
uv.y = (tileScale * -row) - tileScale;
tileOffsets[tileNum] = uv;
tileNum++;
if (tileNum >= numTiles)
{
break;
}
}
if (tileNum >= numTiles)
{
break;
}
}
noise = new FastSimplexNoise();
transitionColor = Color.black;
forces = new Force[fingers.Length];
fingertips = new Fingertip[fingers.Length];
wisps = new Wisp[numWisps];
quads = new Quad[numWisps];
finalQuads = new Quad[numWisps];
renderOrder = new List <RenderOrder>(numWisps);
for (int i = 0; i < numWisps; i++)
{
Wisp wisp = new Wisp();
wisp.TargetPoint = SurfacePosition + (Random.insideUnitSphere * SurfaceRadius);
wisp.Point = wisp.TargetPoint;
wisp.Velocity = Random.insideUnitSphere * initialVelocity;
wisp.TargetRadius = Mathf.Lerp(wispSize.x, wispSize.y, (float)noise.Evaluate(wisp.Point.x, wisp.Point.y, wisp.Point.z));
wisp.Radius = wisp.TargetRadius;
wisp.TileOffset = Random.Range(0, numTiles);
wisps[i] = wisp;
Quad quad = Quad.FromWisp(baseWispColor.Evaluate(Random.Range(0f, 1f)), wisp.Point, wisp.Radius, Vector3.up, Vector3.right, tileOffsets[wisp.TileOffset], tileScale);
quad.Color = transitionColor;
quads[i] = quad;
finalQuads[i] = quads[i];
RenderOrder r = new RenderOrder();
renderOrder.Add(r);
}
for (int i = 0; i < fingers.Length; i++)
{
Transform finger = fingers[i];
Fingertip fingertip = fingertips[i];
fingertip.Block = new MaterialPropertyBlock();
fingertip.Trail = finger.GetComponentInChildren <TrailRenderer>();
fingertip.Mesh = finger.GetComponentInChildren <MeshRenderer>();
fingertip.PingAudio = finger.GetComponentInChildren <AudioSource>();
fingertips[i] = fingertip;
}
Camera.onPostRender += PostRender;
updateWisps = true;
Task task = UpdateWispsTask();
}
