1239 lines
36 KiB
C#
1239 lines
36 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Threading;
|
|
using UnityEngine;
|
|
|
|
// Token: 0x0200000E RID: 14
|
|
public class FOWSystemInterior : MonoBehaviour
|
|
{
|
|
// Token: 0x17000008 RID: 8
|
|
// (get) Token: 0x060000BF RID: 191 RVA: 0x0000F37A File Offset: 0x0000D57A
|
|
public Texture2D texture0
|
|
{
|
|
get
|
|
{
|
|
return this.mTexture0;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000009 RID: 9
|
|
// (get) Token: 0x060000C0 RID: 192 RVA: 0x0000F382 File Offset: 0x0000D582
|
|
public Texture2D texture1
|
|
{
|
|
get
|
|
{
|
|
return this.mTexture1;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700000A RID: 10
|
|
// (get) Token: 0x060000C1 RID: 193 RVA: 0x0000F38A File Offset: 0x0000D58A
|
|
public float blendFactor
|
|
{
|
|
get
|
|
{
|
|
return this.mBlendFactor;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000C2 RID: 194 RVA: 0x0000F392 File Offset: 0x0000D592
|
|
private void Awake()
|
|
{
|
|
FOWSystemInterior.instance = this;
|
|
}
|
|
|
|
// Token: 0x060000C3 RID: 195 RVA: 0x0000F39A File Offset: 0x0000D59A
|
|
private IEnumerator Start()
|
|
{
|
|
while (!FOWSystemInterior.readyToCreate)
|
|
{
|
|
yield return null;
|
|
}
|
|
this.saveFow = true;
|
|
this.mTrans = base.transform;
|
|
this.mHeights = new int[this.textureSize, this.textureSize];
|
|
this.mSize = new Vector3((float)this.worldSize, this.heightRange.y - this.heightRange.x, (float)this.worldSize);
|
|
this.mOrigin = this.mTrans.position;
|
|
this.mOrigin.x = this.mOrigin.x - (float)this.worldSize * 0.5f;
|
|
this.mOrigin.z = this.mOrigin.z - (float)this.worldSize * 0.5f;
|
|
int num = this.textureSize * this.textureSize;
|
|
if (!this.loaded)
|
|
{
|
|
this.mBuffer0 = new Color32[num];
|
|
this.mBuffer1 = new Color32[num];
|
|
this.mBuffer2 = new Color32[num];
|
|
}
|
|
this.CreateGrid();
|
|
if (FOWSystemInterior.onLoad != null)
|
|
{
|
|
FOWSystemInterior.onLoad();
|
|
}
|
|
this.UpdateBuffer();
|
|
this.RebuildTextures();
|
|
this.mNextUpdate = Time.time + this.updateFrequency;
|
|
this.mThread = new Thread(new ThreadStart(this.ThreadUpdate));
|
|
this.mThread.Start();
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x060000C4 RID: 196 RVA: 0x0000F3AC File Offset: 0x0000D5AC
|
|
private void OnDestroy()
|
|
{
|
|
if (this.mThread != null)
|
|
{
|
|
this.mThread.Abort();
|
|
while (this.mThread.IsAlive)
|
|
{
|
|
Thread.Sleep(1);
|
|
}
|
|
this.mThread = null;
|
|
}
|
|
if (FOWSystemInterior.onSave != null)
|
|
{
|
|
FOWSystemInterior.onSave();
|
|
}
|
|
FOWSystemInterior.onLoad = null;
|
|
FOWSystemInterior.onSave = null;
|
|
FOWSystemInterior.instance = null;
|
|
}
|
|
|
|
// Token: 0x060000C5 RID: 197 RVA: 0x0000F40C File Offset: 0x0000D60C
|
|
private void Update()
|
|
{
|
|
if (this.mTrans == null)
|
|
{
|
|
return;
|
|
}
|
|
if (this.textureBlendTime > 0f)
|
|
{
|
|
this.mBlendFactor = Mathf.Clamp01(this.mBlendFactor + Time.unscaledDeltaTime / this.textureBlendTime);
|
|
}
|
|
else
|
|
{
|
|
this.mBlendFactor = 1f;
|
|
}
|
|
if (!this.cameraTarget)
|
|
{
|
|
this.cameraTarget = GameObject.Find("Character Follow").transform;
|
|
GameObject gameObject = GameObject.Find("Main Camera");
|
|
this.cam = gameObject.GetComponent<Camera>();
|
|
}
|
|
RaycastHit raycastHit;
|
|
if (Physics.Raycast(this.cameraTarget.position + new Vector3(0f, 500f, 0f), Vector3.up * -1f, out raycastHit, 10000f, 1073741824))
|
|
{
|
|
this.currentInterior = this.interiorColliders.IndexOf(raycastHit.collider);
|
|
}
|
|
if (this.mState == FOWSystemInterior.State.Blending)
|
|
{
|
|
float time = Time.time;
|
|
if (this.mNextUpdate < time)
|
|
{
|
|
this.mNextUpdate = time + this.updateFrequency;
|
|
this.mState = FOWSystemInterior.State.NeedUpdate;
|
|
}
|
|
}
|
|
else if (this.mState != FOWSystemInterior.State.NeedUpdate)
|
|
{
|
|
if (this.mScreenHeight != Screen.height || this.mTexture0 == null)
|
|
{
|
|
this.RebuildTextures();
|
|
}
|
|
else if (this.mState == FOWSystemInterior.State.UpdateTexture0)
|
|
{
|
|
this.mTexture0.SetPixels32(this.mBuffer0);
|
|
this.mTexture0.Apply();
|
|
this.mState = FOWSystemInterior.State.UpdateTexture1;
|
|
this.mBlendFactor = 0f;
|
|
}
|
|
else if (this.mState == FOWSystemInterior.State.UpdateTexture1)
|
|
{
|
|
this.mTexture1.SetPixels32(this.mBuffer1);
|
|
this.mTexture1.Apply();
|
|
this.mState = FOWSystemInterior.State.Blending;
|
|
}
|
|
}
|
|
float num = 1f / (float)this.worldSize;
|
|
float num2 = this.mTrans.position.x - (float)this.worldSize * 0.5f;
|
|
float num3 = this.mTrans.position.z - (float)this.worldSize * 0.5f;
|
|
Vector4 vector = new Vector4(-num2 * num, -num3 * num, num, this.mBlendFactor);
|
|
Shader.SetGlobalColor("_FOWUnexploredInterior", this.unexploredColor);
|
|
Shader.SetGlobalColor("_FOWExploredInterior", this.exploredColor);
|
|
Shader.SetGlobalVector("_FOWParamsInterior", vector);
|
|
Shader.SetGlobalTexture("_FOWTex0Interior", this.mTexture0);
|
|
Shader.SetGlobalTexture("_FOWTex1Interior", this.mTexture1);
|
|
}
|
|
|
|
// Token: 0x060000C6 RID: 198 RVA: 0x0000F674 File Offset: 0x0000D874
|
|
public void SetGlobalShaderVariables()
|
|
{
|
|
this.isActive = true;
|
|
float num = 1f / (float)this.worldSize;
|
|
float num2 = this.mTrans.position.x - (float)this.worldSize * 0.5f;
|
|
float num3 = this.mTrans.position.z - (float)this.worldSize * 0.5f;
|
|
Vector4 vector = new Vector4(-num2 * num, -num3 * num, num, this.mBlendFactor);
|
|
Shader.SetGlobalColor("_FOWUnexploredInterior", this.unexploredColor);
|
|
Shader.SetGlobalColor("_FOWExploredInterior", this.exploredColor);
|
|
Shader.SetGlobalVector("_FOWParamsInterior", vector);
|
|
Shader.SetGlobalTexture("_FOWTex0Interior", this.mTexture0);
|
|
Shader.SetGlobalTexture("_FOWTex1Interior", this.mTexture1);
|
|
}
|
|
|
|
// Token: 0x060000C7 RID: 199 RVA: 0x0000F738 File Offset: 0x0000D938
|
|
public Vector4 GetParams()
|
|
{
|
|
float num = 1f / (float)this.worldSize;
|
|
float num2 = this.mTrans.position.x - (float)this.worldSize * 0.5f;
|
|
float num3 = this.mTrans.position.z - (float)this.worldSize * 0.5f;
|
|
return new Vector4(-num2 * num, -num3 * num, num, this.mBlendFactor);
|
|
}
|
|
|
|
// Token: 0x060000C8 RID: 200 RVA: 0x0000F7A4 File Offset: 0x0000D9A4
|
|
private void RebuildTextures()
|
|
{
|
|
this.mScreenHeight = Screen.height;
|
|
if (this.mTexture0 != null)
|
|
{
|
|
Object.Destroy(this.mTexture0);
|
|
}
|
|
if (this.mTexture1 != null)
|
|
{
|
|
Object.Destroy(this.mTexture1);
|
|
}
|
|
bool flag = QualitySettings.activeColorSpace == ColorSpace.Linear;
|
|
this.mTexture0 = new Texture2D(this.textureSize, this.textureSize, TextureFormat.ARGB32, false, flag);
|
|
this.mTexture1 = new Texture2D(this.textureSize, this.textureSize, TextureFormat.ARGB32, false, flag);
|
|
this.mTexture0.wrapMode = TextureWrapMode.Clamp;
|
|
this.mTexture1.wrapMode = TextureWrapMode.Clamp;
|
|
this.mTexture0.SetPixels32(this.mBuffer0);
|
|
this.mTexture0.Apply();
|
|
this.mTexture1.SetPixels32(this.mBuffer1);
|
|
this.mTexture1.Apply();
|
|
this.mState = FOWSystemInterior.State.Blending;
|
|
}
|
|
|
|
// Token: 0x060000C9 RID: 201 RVA: 0x0000F884 File Offset: 0x0000DA84
|
|
private void ThreadUpdate()
|
|
{
|
|
Stopwatch stopwatch = new Stopwatch();
|
|
for (;;)
|
|
{
|
|
if (this.mState == FOWSystemInterior.State.NeedUpdate)
|
|
{
|
|
stopwatch.Reset();
|
|
stopwatch.Start();
|
|
this.UpdateBuffer();
|
|
stopwatch.Stop();
|
|
if (this.debug)
|
|
{
|
|
Debug.Log(stopwatch.ElapsedMilliseconds);
|
|
}
|
|
this.mElapsed = 0.001f * (float)stopwatch.ElapsedMilliseconds;
|
|
this.mState = FOWSystemInterior.State.UpdateTexture0;
|
|
}
|
|
Thread.Sleep(1);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000CA RID: 202 RVA: 0x0000F8F4 File Offset: 0x0000DAF4
|
|
private void OnDrawGizmosSelected()
|
|
{
|
|
Gizmos.matrix = base.transform.localToWorldMatrix;
|
|
Gizmos.color = Color.yellow;
|
|
Gizmos.DrawWireCube(new Vector3(0f, (this.heightRange.x + this.heightRange.y) * 0.5f, 0f), new Vector3((float)this.worldSize, this.heightRange.y - this.heightRange.x, (float)this.worldSize));
|
|
}
|
|
|
|
// Token: 0x060000CB RID: 203 RVA: 0x0000F978 File Offset: 0x0000DB78
|
|
private bool IsVisible(int sx, int sy, int fx, int fy, float outer, int sightHeight, int variance)
|
|
{
|
|
int num = Mathf.Abs(fx - sx);
|
|
int num2 = Mathf.Abs(fy - sy);
|
|
int num3 = ((sx < fx) ? 1 : (-1));
|
|
int num4 = ((sy < fy) ? 1 : (-1));
|
|
int num5 = num - num2;
|
|
float num6 = (float)sightHeight;
|
|
float num7 = (float)this.mHeights[fx, fy];
|
|
float num8 = 1f / outer;
|
|
while (sx != fx || sy != fy)
|
|
{
|
|
int num9 = fx - sx;
|
|
int num10 = fy - sy;
|
|
float num11 = num8 * Mathf.Sqrt((float)(num9 * num9 + num10 * num10));
|
|
if ((float)this.mHeights[sx, sy] > Mathf.Lerp(num7, num6, num11) + (float)variance)
|
|
{
|
|
return false;
|
|
}
|
|
int num12 = num5 << 1;
|
|
if (num12 > -num2)
|
|
{
|
|
num5 -= num2;
|
|
sx += num3;
|
|
}
|
|
if (num12 < num)
|
|
{
|
|
num5 += num;
|
|
sy += num4;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x060000CC RID: 204 RVA: 0x0000FA47 File Offset: 0x0000DC47
|
|
public int WorldToGridHeight(float height)
|
|
{
|
|
return Mathf.Clamp(Mathf.RoundToInt(height / this.mSize.y * 255f), 0, 255);
|
|
}
|
|
|
|
// Token: 0x060000CD RID: 205 RVA: 0x0000FA6C File Offset: 0x0000DC6C
|
|
public virtual void CreateGrid()
|
|
{
|
|
Vector3 vector = this.mOrigin;
|
|
vector.y += this.mSize.y;
|
|
float num = (float)this.worldSize / (float)this.textureSize;
|
|
float num2 = this.raycastRadius;
|
|
this.mInteriors = new int[this.mBuffer0.Length];
|
|
Ray ray = new Ray(Vector3.zero, Vector3.down);
|
|
this.interiors = GameObject.Find("Capture B");
|
|
if (this.interiors)
|
|
{
|
|
this.interiorsTr = this.interiors.transform;
|
|
}
|
|
this.interiorColliders.Clear();
|
|
GameObject gameObject = GameObject.Find("Character Follow");
|
|
if (gameObject)
|
|
{
|
|
this.cameraTarget = gameObject.transform;
|
|
}
|
|
if (this.interiors)
|
|
{
|
|
foreach (object obj in this.interiorsTr)
|
|
{
|
|
Transform transform = (Transform)obj;
|
|
if (transform != this.interiorsTr)
|
|
{
|
|
Collider component = transform.gameObject.GetComponent<Collider>();
|
|
if (component && transform.childCount > 0)
|
|
{
|
|
this.interiorColliders.Add(component);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
int num3 = 0;
|
|
for (int i = 0; i < this.textureSize; i++)
|
|
{
|
|
vector.z = this.mOrigin.z + (float)i * num;
|
|
int j = 0;
|
|
while (j < this.textureSize)
|
|
{
|
|
vector.x = this.mOrigin.x + (float)j * num;
|
|
ray.origin = vector;
|
|
RaycastHit raycastHit;
|
|
if (Physics.Raycast(new Vector3(vector.x, 1000f, vector.z), Vector3.up * -1f, out raycastHit, 3000f, 1073741824))
|
|
{
|
|
this.mInteriors[num3] = this.interiorColliders.IndexOf(raycastHit.collider);
|
|
}
|
|
num3++;
|
|
RaycastHit raycastHit2;
|
|
if (!Physics.SphereCast(ray, this.raycastRadius, out raycastHit2, this.mSize.y, this.raycastMask))
|
|
{
|
|
goto IL_026B;
|
|
}
|
|
bool flag = false;
|
|
if (raycastHit2.collider.gameObject.layer == 16 && raycastHit2.collider.gameObject.GetComponent<Puzzle>())
|
|
{
|
|
flag = true;
|
|
}
|
|
if (flag)
|
|
{
|
|
goto IL_026B;
|
|
}
|
|
this.mHeights[j, i] = this.WorldToGridHeight(vector.y - raycastHit2.distance - this.raycastRadius);
|
|
IL_027B:
|
|
j++;
|
|
continue;
|
|
IL_026B:
|
|
this.mHeights[j, i] = 0;
|
|
goto IL_027B;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000CE RID: 206 RVA: 0x0000FD2C File Offset: 0x0000DF2C
|
|
public void UpdateGrid(Vector3 center, float radius)
|
|
{
|
|
Vector3 vector = this.mOrigin;
|
|
vector.y += this.mSize.y;
|
|
float num = (float)this.worldSize / (float)this.textureSize;
|
|
float num2 = this.raycastRadius;
|
|
Vector3 vector2 = this.mOrigin;
|
|
Ray ray = new Ray(Vector3.zero, Vector3.down);
|
|
for (int i = 0; i < this.textureSize; i++)
|
|
{
|
|
vector.z = this.mOrigin.z + (float)i * num;
|
|
for (int j = 0; j < this.textureSize; j++)
|
|
{
|
|
vector.x = this.mOrigin.x + (float)j * num;
|
|
bool flag = false;
|
|
vector2 = this.mOrigin;
|
|
vector2.x += (float)j;
|
|
vector2.z += (float)i;
|
|
vector2 = vector;
|
|
center.y = vector2.y;
|
|
ray.origin = vector;
|
|
if ((vector2 - center).sqrMagnitude < radius * radius)
|
|
{
|
|
flag = true;
|
|
}
|
|
RaycastHit raycastHit;
|
|
if (flag && Physics.SphereCast(ray, this.raycastRadius, out raycastHit, this.mSize.y, this.raycastMask))
|
|
{
|
|
bool flag2 = false;
|
|
if (raycastHit.collider.gameObject.layer == 16 && raycastHit.collider.gameObject.GetComponent<Puzzle>())
|
|
{
|
|
flag2 = true;
|
|
}
|
|
if (!flag2)
|
|
{
|
|
this.mHeights[j, i] = this.WorldToGridHeight(vector.y - raycastHit.distance - this.raycastRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000CF RID: 207 RVA: 0x0000FED4 File Offset: 0x0000E0D4
|
|
private void UpdateBuffer()
|
|
{
|
|
if (FOWSystemInterior.mAdded.Count > 0)
|
|
{
|
|
List<FOWSystemInterior.Revealer> list = FOWSystemInterior.mAdded;
|
|
lock (list)
|
|
{
|
|
while (FOWSystemInterior.mAdded.Count > 0)
|
|
{
|
|
int num = FOWSystemInterior.mAdded.Count - 1;
|
|
FOWSystemInterior.mRevealers.Add(FOWSystemInterior.mAdded[num]);
|
|
FOWSystemInterior.mAdded.RemoveAt(num);
|
|
}
|
|
}
|
|
}
|
|
if (FOWSystemInterior.mRemoved.Count > 0)
|
|
{
|
|
List<FOWSystemInterior.Revealer> list = FOWSystemInterior.mRemoved;
|
|
lock (list)
|
|
{
|
|
while (FOWSystemInterior.mRemoved.Count > 0)
|
|
{
|
|
int num2 = FOWSystemInterior.mRemoved.Count - 1;
|
|
FOWSystemInterior.mRevealers.Remove(FOWSystemInterior.mRemoved[num2]);
|
|
FOWSystemInterior.mRemoved.RemoveAt(num2);
|
|
}
|
|
}
|
|
}
|
|
float num3 = ((this.textureBlendTime > 0f) ? Mathf.Clamp01(this.mBlendFactor + this.mElapsed / this.textureBlendTime) : 1f);
|
|
int i = 0;
|
|
int num4 = this.mBuffer0.Length;
|
|
while (i < num4)
|
|
{
|
|
this.mBuffer0[i] = Color32.Lerp(this.mBuffer0[i], this.mBuffer1[i], num3);
|
|
this.mBuffer1[i].r = 0;
|
|
i++;
|
|
}
|
|
float num5 = (float)this.textureSize / (float)this.worldSize;
|
|
int j = 0;
|
|
int count = FOWSystemInterior.mRevealers.Count;
|
|
while (j < count)
|
|
{
|
|
FOWSystemInterior.Revealer revealer = FOWSystemInterior.mRevealers[j];
|
|
if (revealer.isActive)
|
|
{
|
|
FOWSystemInterior.Revealer revealer2 = revealer;
|
|
lock (revealer2)
|
|
{
|
|
if (revealer.los == FOWSystemInterior.LOSChecks.None)
|
|
{
|
|
this.RevealUsingRadius(revealer, num5);
|
|
}
|
|
else if (revealer.los == FOWSystemInterior.LOSChecks.OnlyOnce)
|
|
{
|
|
this.RevealUsingCache(revealer, num5);
|
|
}
|
|
else
|
|
{
|
|
this.RevealUsingLOS(revealer, num5);
|
|
}
|
|
}
|
|
}
|
|
j++;
|
|
}
|
|
for (int k = 0; k < this.blurIterations; k++)
|
|
{
|
|
this.BlurVisibility();
|
|
}
|
|
this.RevealVisible();
|
|
}
|
|
|
|
// Token: 0x060000D0 RID: 208 RVA: 0x00010118 File Offset: 0x0000E318
|
|
private void RevealUsingRadius(FOWSystemInterior.Revealer r, float worldToTex)
|
|
{
|
|
Vector3 vector = r.pos - this.mOrigin;
|
|
int num = Mathf.RoundToInt((vector.x - r.outer) * worldToTex);
|
|
int num2 = Mathf.RoundToInt((vector.z - r.outer) * worldToTex);
|
|
int num3 = Mathf.RoundToInt((vector.x + r.outer) * worldToTex);
|
|
int num4 = Mathf.RoundToInt((vector.z + r.outer) * worldToTex);
|
|
int num5 = Mathf.RoundToInt(vector.x * worldToTex);
|
|
int num6 = Mathf.RoundToInt(vector.z * worldToTex);
|
|
num5 = Mathf.Clamp(num5, 0, this.textureSize - 1);
|
|
num6 = Mathf.Clamp(num6, 0, this.textureSize - 1);
|
|
int num7 = Mathf.RoundToInt(r.outer * r.outer * worldToTex * worldToTex);
|
|
int num8 = this.textureSize - 1;
|
|
for (int i = num2; i < num4; i++)
|
|
{
|
|
if (i > 0 && i < num8)
|
|
{
|
|
int num9 = i * this.textureSize;
|
|
for (int j = num; j < num3; j++)
|
|
{
|
|
if (j > 0 && j < num8)
|
|
{
|
|
int num10 = j - num5;
|
|
int num11 = i - num6;
|
|
if (num10 * num10 + num11 * num11 < num7)
|
|
{
|
|
this.mBuffer1[j + num9].r = byte.MaxValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000D1 RID: 209 RVA: 0x00010260 File Offset: 0x0000E460
|
|
private void RevealUsingLOS(FOWSystemInterior.Revealer r, float worldToTex)
|
|
{
|
|
Vector3 vector = r.pos - this.mOrigin;
|
|
int num = Mathf.RoundToInt((vector.x - r.outer) * worldToTex);
|
|
int num2 = Mathf.RoundToInt((vector.z - r.outer) * worldToTex);
|
|
int num3 = Mathf.RoundToInt((vector.x + r.outer) * worldToTex);
|
|
int num4 = Mathf.RoundToInt((vector.z + r.outer) * worldToTex);
|
|
num = Mathf.Clamp(num, 0, this.textureSize - 1);
|
|
num3 = Mathf.Clamp(num3, 0, this.textureSize - 1);
|
|
num2 = Mathf.Clamp(num2, 0, this.textureSize - 1);
|
|
num4 = Mathf.Clamp(num4, 0, this.textureSize - 1);
|
|
int num5 = Mathf.RoundToInt(vector.x * worldToTex);
|
|
int num6 = Mathf.RoundToInt(vector.z * worldToTex);
|
|
num5 = Mathf.Clamp(num5, 0, this.textureSize - 1);
|
|
num6 = Mathf.Clamp(num6, 0, this.textureSize - 1);
|
|
int num7 = Mathf.RoundToInt(r.inner * r.inner * worldToTex * worldToTex);
|
|
int num8 = Mathf.RoundToInt(r.outer * r.outer * worldToTex * worldToTex);
|
|
int num9 = this.WorldToGridHeight(r.pos.y);
|
|
int num10 = Mathf.RoundToInt(Mathf.Clamp01(this.margin / (this.heightRange.y - this.heightRange.x)) * 255f);
|
|
Color32 color = new Color32(byte.MaxValue, 0, byte.MaxValue, byte.MaxValue);
|
|
int num11 = this.textureSize - 1;
|
|
for (int i = num2; i < num4; i++)
|
|
{
|
|
if (i > 0 && i < num11)
|
|
{
|
|
for (int j = num; j < num3; j++)
|
|
{
|
|
if (j > 0 && j < num11)
|
|
{
|
|
int num12 = j - num5;
|
|
int num13 = i - num6;
|
|
int num14 = num12 * num12 + num13 * num13;
|
|
int num15 = j + i * this.textureSize;
|
|
if (num14 < num7 || (num5 == j && num6 == i))
|
|
{
|
|
color = this.mBuffer1[num15];
|
|
color.r = 1;
|
|
this.mBuffer1[num15] = color;
|
|
}
|
|
else if (num14 < num8)
|
|
{
|
|
Vector2 vector2 = new Vector2((float)num12, (float)num13);
|
|
vector2.Normalize();
|
|
vector2 *= r.inner;
|
|
int num16 = num5 + Mathf.RoundToInt(vector2.x);
|
|
int num17 = num6 + Mathf.RoundToInt(vector2.y);
|
|
if (num16 > -1 && num16 < this.textureSize && num17 > -1 && num17 < this.textureSize && this.IsVisible(num16, num17, j, i, Mathf.Sqrt((float)num14), num9, num10))
|
|
{
|
|
color = this.mBuffer1[num15];
|
|
color.r = byte.MaxValue;
|
|
this.mBuffer1[num15] = color;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000D2 RID: 210 RVA: 0x00010550 File Offset: 0x0000E750
|
|
private void RevealUsingCache(FOWSystemInterior.Revealer r, float worldToTex)
|
|
{
|
|
if (!r.isValid)
|
|
{
|
|
this.RevealIntoCache(r, worldToTex);
|
|
}
|
|
Color32 color = new Color32(byte.MaxValue, 0, byte.MaxValue, byte.MaxValue);
|
|
bool[] cachedBuffer = r.cachedBuffer;
|
|
int num = this.textureSize - 1;
|
|
int i = r.cachedY;
|
|
int num2 = r.cachedY + r.cachedSize;
|
|
while (i < num2)
|
|
{
|
|
if (i > 0 && i < num)
|
|
{
|
|
int num3 = i * this.textureSize;
|
|
int num4 = (i - r.cachedY) * r.cachedSize;
|
|
int j = r.cachedX;
|
|
int num5 = r.cachedX + r.cachedSize;
|
|
while (j < num5)
|
|
{
|
|
if (j > 0 && j < num)
|
|
{
|
|
int num6 = j - r.cachedX + num4;
|
|
if (cachedBuffer[num6])
|
|
{
|
|
color = this.mBuffer1[j + num3];
|
|
color.r = byte.MaxValue;
|
|
this.mBuffer1[j + num3] = color;
|
|
}
|
|
}
|
|
j++;
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000D3 RID: 211 RVA: 0x00010658 File Offset: 0x0000E858
|
|
private void RevealIntoCache(FOWSystemInterior.Revealer r, float worldToTex)
|
|
{
|
|
Vector3 vector = r.pos - this.mOrigin;
|
|
int num = Mathf.RoundToInt((vector.x - r.outer) * worldToTex);
|
|
int num2 = Mathf.RoundToInt((vector.z - r.outer) * worldToTex);
|
|
int num3 = Mathf.RoundToInt((vector.x + r.outer) * worldToTex);
|
|
int num4 = Mathf.RoundToInt((vector.z + r.outer) * worldToTex);
|
|
int num5 = Mathf.RoundToInt(vector.x * worldToTex);
|
|
int num6 = Mathf.RoundToInt(vector.z * worldToTex);
|
|
num5 = Mathf.Clamp(num5, 0, this.textureSize - 1);
|
|
num6 = Mathf.Clamp(num6, 0, this.textureSize - 1);
|
|
int num7 = Mathf.Max(Mathf.RoundToInt((float)(num3 - num)), Mathf.RoundToInt((float)(num4 - num2)));
|
|
int num8 = num7 * num7;
|
|
if (r.cachedBuffer == null || r.cachedBuffer.Length != num8)
|
|
{
|
|
r.cachedBuffer = new bool[num8];
|
|
}
|
|
int i = 0;
|
|
int num9 = num7 * num7;
|
|
while (i < num9)
|
|
{
|
|
r.cachedBuffer[i] = false;
|
|
i++;
|
|
}
|
|
int num10 = Mathf.RoundToInt(r.inner * r.inner * worldToTex * worldToTex);
|
|
int num11 = Mathf.RoundToInt(r.outer * r.outer * worldToTex * worldToTex);
|
|
int num12 = Mathf.RoundToInt(Mathf.Clamp01(this.margin / (this.heightRange.y - this.heightRange.x)) * 255f);
|
|
int num13 = this.WorldToGridHeight(r.pos.y);
|
|
int num14 = this.textureSize - 1;
|
|
for (int j = num2; j < num4; j++)
|
|
{
|
|
if (j > 0 && j < num14)
|
|
{
|
|
for (int k = num; k < num3; k++)
|
|
{
|
|
if (k > 0 && k < num14)
|
|
{
|
|
int num15 = k - num5;
|
|
int num16 = j - num6;
|
|
int num17 = num15 * num15 + num16 * num16;
|
|
if (num17 < num10 || (num5 == k && num6 == j))
|
|
{
|
|
r.cachedBuffer[k - num + (j - num2) * num7] = true;
|
|
}
|
|
else if (num17 < num11)
|
|
{
|
|
Vector2 vector2 = new Vector2((float)num15, (float)num16);
|
|
vector2.Normalize();
|
|
vector2 *= r.inner;
|
|
int num18 = num5 + Mathf.RoundToInt(vector2.x * worldToTex);
|
|
int num19 = num6 + Mathf.RoundToInt(vector2.y * worldToTex);
|
|
if (num18 > -1 && num18 < this.textureSize && num19 > -1 && num19 < this.textureSize && this.IsVisible(num18, num19, k, j, Mathf.Sqrt((float)num17), num13, num12))
|
|
{
|
|
r.cachedBuffer[k - num + (j - num2) * num7] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
r.cachedSize = num7;
|
|
r.cachedX = num;
|
|
r.cachedY = num2;
|
|
r.isValid = true;
|
|
}
|
|
|
|
// Token: 0x060000D4 RID: 212 RVA: 0x0001093C File Offset: 0x0000EB3C
|
|
private void BlurVisibility()
|
|
{
|
|
for (int i = 0; i < this.textureSize; i++)
|
|
{
|
|
int num = i * this.textureSize;
|
|
int num2 = i - 1;
|
|
if (num2 < 0)
|
|
{
|
|
num2 = 0;
|
|
}
|
|
int num3 = i + 1;
|
|
if (num3 == this.textureSize)
|
|
{
|
|
num3 = i;
|
|
}
|
|
num2 *= this.textureSize;
|
|
num3 *= this.textureSize;
|
|
for (int j = 0; j < this.textureSize; j++)
|
|
{
|
|
int num4 = j - 1;
|
|
if (num4 < 0)
|
|
{
|
|
num4 = 0;
|
|
}
|
|
int num5 = j + 1;
|
|
if (num5 == this.textureSize)
|
|
{
|
|
num5 = j;
|
|
}
|
|
int num6 = j + num;
|
|
int num7 = (int)this.mBuffer1[num6].r;
|
|
num7 += (int)this.mBuffer1[num4 + num].r;
|
|
num7 += (int)this.mBuffer1[num5 + num].r;
|
|
num7 += (int)this.mBuffer1[j + num2].r;
|
|
num7 += (int)this.mBuffer1[j + num3].r;
|
|
num7 += (int)this.mBuffer1[num4 + num2].r;
|
|
num7 += (int)this.mBuffer1[num5 + num2].r;
|
|
num7 += (int)this.mBuffer1[num4 + num3].r;
|
|
num7 += (int)this.mBuffer1[num5 + num3].r;
|
|
Color32 color = this.mBuffer2[num6];
|
|
color.r = (byte)(num7 / 9);
|
|
num7 = (int)this.mBuffer1[num6].g;
|
|
num7 += (int)this.mBuffer1[num4 + num].g;
|
|
num7 += (int)this.mBuffer1[num5 + num].g;
|
|
num7 += (int)this.mBuffer1[j + num2].g;
|
|
num7 += (int)this.mBuffer1[j + num3].g;
|
|
color.g = (byte)(num7 / 5);
|
|
this.mBuffer2[num6] = color;
|
|
}
|
|
}
|
|
Color32[] array = this.mBuffer1;
|
|
this.mBuffer1 = this.mBuffer2;
|
|
this.mBuffer2 = array;
|
|
}
|
|
|
|
// Token: 0x060000D5 RID: 213 RVA: 0x00010B8C File Offset: 0x0000ED8C
|
|
public void UpdateInterior(BoxCollider coll)
|
|
{
|
|
BoxCollider boxCollider = null;
|
|
if (coll)
|
|
{
|
|
boxCollider = coll.gameObject.transform.parent.gameObject.GetComponent<BoxCollider>();
|
|
}
|
|
this.currentInterior = this.interiorColliders.IndexOf(boxCollider);
|
|
this.RevealVisible();
|
|
this.mTexture0.SetPixels32(this.mBuffer1);
|
|
this.mTexture0.Apply();
|
|
this.mTexture1.SetPixels32(this.mBuffer1);
|
|
this.mTexture1.Apply();
|
|
}
|
|
|
|
// Token: 0x060000D6 RID: 214 RVA: 0x00010C0E File Offset: 0x0000EE0E
|
|
public void UpdateInteriorFromChange()
|
|
{
|
|
this.RevealVisible();
|
|
this.mTexture0.SetPixels32(this.mBuffer1);
|
|
this.mTexture0.Apply();
|
|
this.mTexture1.SetPixels32(this.mBuffer1);
|
|
this.mTexture1.Apply();
|
|
}
|
|
|
|
// Token: 0x060000D7 RID: 215 RVA: 0x00010C50 File Offset: 0x0000EE50
|
|
private void RevealVisible()
|
|
{
|
|
for (int i = 0; i < this.textureSize; i++)
|
|
{
|
|
int num = i * this.textureSize;
|
|
for (int j = 0; j < this.textureSize; j++)
|
|
{
|
|
int num2 = j + num;
|
|
Color32 color = this.mBuffer1[num2];
|
|
if (color.b < color.r && this.saveFow)
|
|
{
|
|
color.b = color.r;
|
|
}
|
|
if (this.currentInterior == this.mInteriors[num2])
|
|
{
|
|
color.g = byte.MaxValue;
|
|
}
|
|
else
|
|
{
|
|
color.g = 0;
|
|
}
|
|
this.mBuffer1[num2] = color;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000D8 RID: 216 RVA: 0x00010CFC File Offset: 0x0000EEFC
|
|
public void Save()
|
|
{
|
|
FOWSystemInterior.GetRevealedBuffer();
|
|
int num = FOWSystemInterior.instance.textureSize * FOWSystemInterior.instance.textureSize;
|
|
List<float> list = new List<float>();
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
list.Add((float)FOWSystemInterior.instance.mBuffer0[i].b);
|
|
}
|
|
if (Records.x.inOverworldMap)
|
|
{
|
|
Links.x.gaia.UpdateOverworldFow(list);
|
|
return;
|
|
}
|
|
ES3.Save<List<float>>("FowInterior", list, Records.x.openBook + "/" + Links.x.diorama.sceneName + "_FOW");
|
|
}
|
|
|
|
// Token: 0x060000D9 RID: 217 RVA: 0x00010DA4 File Offset: 0x0000EFA4
|
|
public void Load()
|
|
{
|
|
string text = Records.x.openBook + "/" + Links.x.diorama.sceneName + "_FOW";
|
|
if (ES3.FileExists(text))
|
|
{
|
|
List<float> list = ES3.Load<List<float>>("FowInterior", text);
|
|
int num = FOWSystemInterior.instance.textureSize * FOWSystemInterior.instance.textureSize;
|
|
if (list.Count != num)
|
|
{
|
|
Debug.LogError("Buffer size mismatch. Fog is " + num.ToString() + ", but passed array is " + list.Count.ToString());
|
|
}
|
|
else
|
|
{
|
|
if (FOWSystemInterior.instance.mBuffer0 == null)
|
|
{
|
|
FOWSystemInterior.instance.mBuffer0 = new Color32[num];
|
|
FOWSystemInterior.instance.mBuffer1 = new Color32[num];
|
|
FOWSystemInterior.instance.mBuffer2 = new Color32[num];
|
|
}
|
|
this.loaded = true;
|
|
Color color = default(Color);
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
color.r = (float)FOWSystemInterior.instance.mBuffer0[i].r;
|
|
color.b = list[i];
|
|
color.g = (float)FOWSystemInterior.instance.mBuffer0[i].g;
|
|
color.a = (float)FOWSystemInterior.instance.mBuffer0[i].a;
|
|
FOWSystemInterior.instance.mBuffer0[i] = color;
|
|
color.r = (float)FOWSystemInterior.instance.mBuffer1[i].r;
|
|
color.b = list[i];
|
|
color.g = (float)FOWSystemInterior.instance.mBuffer1[i].g;
|
|
color.a = (float)FOWSystemInterior.instance.mBuffer1[i].a;
|
|
FOWSystemInterior.instance.mBuffer1[i] = color;
|
|
}
|
|
}
|
|
this.RebuildTextures();
|
|
for (int j = 0; j < this.textureSize; j++)
|
|
{
|
|
int num2 = j * this.textureSize;
|
|
int num3 = j - 1;
|
|
if (num3 < 0)
|
|
{
|
|
num3 = 0;
|
|
}
|
|
int num4 = j + 1;
|
|
if (num4 == this.textureSize)
|
|
{
|
|
num4 = j;
|
|
}
|
|
num3 *= this.textureSize;
|
|
num4 *= this.textureSize;
|
|
for (int k = 0; k < this.textureSize; k++)
|
|
{
|
|
int num5 = k - 1;
|
|
if (num5 < 0)
|
|
{
|
|
num5 = 0;
|
|
}
|
|
int num6 = k + 1;
|
|
if (num6 == this.textureSize)
|
|
{
|
|
num6 = k;
|
|
}
|
|
int num7 = k + num2;
|
|
int num8 = (int)FOWSystemInterior.instance.mBuffer1[num7].b;
|
|
num8 += (int)FOWSystemInterior.instance.mBuffer1[num5 + num2].b;
|
|
num8 += (int)FOWSystemInterior.instance.mBuffer1[num6 + num2].b;
|
|
num8 += (int)FOWSystemInterior.instance.mBuffer1[k + num3].b;
|
|
num8 += (int)FOWSystemInterior.instance.mBuffer1[k + num4].b;
|
|
num8 += (int)FOWSystemInterior.instance.mBuffer1[num5 + num3].b;
|
|
num8 += (int)FOWSystemInterior.instance.mBuffer1[num6 + num3].b;
|
|
num8 += (int)FOWSystemInterior.instance.mBuffer1[num5 + num4].b;
|
|
num8 += (int)FOWSystemInterior.instance.mBuffer1[num6 + num4].b;
|
|
Color32 color2 = FOWSystemInterior.instance.mBuffer2[num7];
|
|
color2.b = (byte)(num8 / 9);
|
|
FOWSystemInterior.instance.mBuffer2[num7] = color2;
|
|
}
|
|
}
|
|
Color32[] array = FOWSystemInterior.instance.mBuffer1;
|
|
FOWSystemInterior.instance.mBuffer1 = FOWSystemInterior.instance.mBuffer2;
|
|
FOWSystemInterior.instance.mBuffer2 = array;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000DA RID: 218 RVA: 0x000111B0 File Offset: 0x0000F3B0
|
|
public static byte[] GetRevealedBuffer()
|
|
{
|
|
if (FOWSystemInterior.instance == null || FOWSystemInterior.instance.mBuffer1 == null)
|
|
{
|
|
return null;
|
|
}
|
|
int num = FOWSystemInterior.instance.textureSize * FOWSystemInterior.instance.textureSize;
|
|
byte[] array = new byte[num];
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
array[i] = FOWSystemInterior.instance.mBuffer1[i].b;
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x060000DB RID: 219 RVA: 0x0001121C File Offset: 0x0000F41C
|
|
public static void SetRevealedBuffer(byte[] arr)
|
|
{
|
|
if (FOWSystemInterior.instance == null || arr == null)
|
|
{
|
|
return;
|
|
}
|
|
int num = FOWSystemInterior.instance.textureSize * FOWSystemInterior.instance.textureSize;
|
|
if (arr.Length != num)
|
|
{
|
|
Debug.LogError("Buffer size mismatch. Fog is " + num.ToString() + ", but passed array is " + arr.Length.ToString());
|
|
return;
|
|
}
|
|
if (FOWSystemInterior.instance.mBuffer0 == null)
|
|
{
|
|
FOWSystemInterior.instance.mBuffer0 = new Color32[num];
|
|
FOWSystemInterior.instance.mBuffer1 = new Color32[num];
|
|
}
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
FOWSystemInterior.instance.mBuffer0[i].b = arr[i];
|
|
FOWSystemInterior.instance.mBuffer1[i].b = arr[i];
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000DC RID: 220 RVA: 0x000112E8 File Offset: 0x0000F4E8
|
|
public static void RevealAll()
|
|
{
|
|
if (FOWSystemInterior.instance == null)
|
|
{
|
|
return;
|
|
}
|
|
int num = FOWSystemInterior.instance.textureSize * FOWSystemInterior.instance.textureSize;
|
|
if (FOWSystemInterior.instance.mBuffer0 == null)
|
|
{
|
|
FOWSystemInterior.instance.mBuffer0 = new Color32[num];
|
|
FOWSystemInterior.instance.mBuffer1 = new Color32[num];
|
|
}
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
FOWSystemInterior.instance.mBuffer0[i].g = byte.MaxValue;
|
|
FOWSystemInterior.instance.mBuffer1[i].g = byte.MaxValue;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000DD RID: 221 RVA: 0x00011388 File Offset: 0x0000F588
|
|
public static FOWSystemInterior.Revealer CreateRevealer()
|
|
{
|
|
FOWSystemInterior.Revealer revealer = new FOWSystemInterior.Revealer();
|
|
revealer.isActive = false;
|
|
List<FOWSystemInterior.Revealer> list = FOWSystemInterior.mAdded;
|
|
lock (list)
|
|
{
|
|
FOWSystemInterior.mAdded.Add(revealer);
|
|
}
|
|
return revealer;
|
|
}
|
|
|
|
// Token: 0x060000DE RID: 222 RVA: 0x000113DC File Offset: 0x0000F5DC
|
|
public static void DeleteRevealer(FOWSystemInterior.Revealer rev)
|
|
{
|
|
List<FOWSystemInterior.Revealer> list = FOWSystemInterior.mRemoved;
|
|
lock (list)
|
|
{
|
|
FOWSystemInterior.mRemoved.Add(rev);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000DF RID: 223 RVA: 0x00011420 File Offset: 0x0000F620
|
|
public bool IsVisible(Vector3 pos)
|
|
{
|
|
FOWSystemInterior fowsystemInterior = FOWSystemInterior.instance;
|
|
if (fowsystemInterior == null)
|
|
{
|
|
return true;
|
|
}
|
|
if (fowsystemInterior.mBuffer0 == null)
|
|
{
|
|
return false;
|
|
}
|
|
pos -= fowsystemInterior.mOrigin;
|
|
float num = (float)fowsystemInterior.textureSize / (float)fowsystemInterior.worldSize;
|
|
int num2 = Mathf.RoundToInt(pos.x * num);
|
|
int num3 = Mathf.RoundToInt(pos.z * num);
|
|
int num4 = Mathf.Clamp(num2, 0, fowsystemInterior.textureSize - 1);
|
|
num3 = Mathf.Clamp(num3, 0, fowsystemInterior.textureSize - 1);
|
|
int num5 = num4 + num3 * fowsystemInterior.textureSize;
|
|
return fowsystemInterior.mBuffer1[num5].r > 0 || fowsystemInterior.mBuffer0[num5].r > 0;
|
|
}
|
|
|
|
// Token: 0x060000E0 RID: 224 RVA: 0x000114D4 File Offset: 0x0000F6D4
|
|
public bool IsVisibleWorm(Vector3 pos)
|
|
{
|
|
FOWSystemInterior fowsystemInterior = FOWSystemInterior.instance;
|
|
if (fowsystemInterior == null)
|
|
{
|
|
return true;
|
|
}
|
|
if (fowsystemInterior.mBuffer0 == null)
|
|
{
|
|
return false;
|
|
}
|
|
pos -= fowsystemInterior.mOrigin;
|
|
float num = (float)fowsystemInterior.textureSize / (float)fowsystemInterior.worldSize;
|
|
int num2 = Mathf.RoundToInt(pos.x * num);
|
|
int num3 = Mathf.RoundToInt(pos.z * num);
|
|
int num4 = Mathf.Clamp(num2, 0, fowsystemInterior.textureSize - 1);
|
|
num3 = Mathf.Clamp(num3, 0, fowsystemInterior.textureSize - 1);
|
|
int num5 = num4 + num3 * fowsystemInterior.textureSize;
|
|
return fowsystemInterior.mBuffer1[num5].b > 0 || fowsystemInterior.mBuffer0[num5].b > 0;
|
|
}
|
|
|
|
// Token: 0x060000E1 RID: 225 RVA: 0x00011588 File Offset: 0x0000F788
|
|
public static bool IsExplored(Vector3 pos)
|
|
{
|
|
FOWSystemInterior fowsystemInterior = FOWSystemInterior.instance;
|
|
if (fowsystemInterior == null)
|
|
{
|
|
return true;
|
|
}
|
|
if (fowsystemInterior.mBuffer0 == null)
|
|
{
|
|
return false;
|
|
}
|
|
pos -= fowsystemInterior.mOrigin;
|
|
float num = (float)fowsystemInterior.textureSize / (float)fowsystemInterior.worldSize;
|
|
int num2 = Mathf.RoundToInt(pos.x * num);
|
|
int num3 = Mathf.RoundToInt(pos.z * num);
|
|
num2 = Mathf.Clamp(num2, 0, fowsystemInterior.textureSize - 1);
|
|
num3 = Mathf.Clamp(num3, 0, fowsystemInterior.textureSize - 1);
|
|
return fowsystemInterior.mBuffer0[num2 + num3 * fowsystemInterior.textureSize].g > 0;
|
|
}
|
|
|
|
// Token: 0x04000227 RID: 551
|
|
[Header("Joseph")]
|
|
public int worldSize = 256;
|
|
|
|
// Token: 0x04000228 RID: 552
|
|
public int index;
|
|
|
|
// Token: 0x04000229 RID: 553
|
|
public bool isActive;
|
|
|
|
// Token: 0x0400022A RID: 554
|
|
public static FOWSystemInterior.OnSaveOrLoad onSave;
|
|
|
|
// Token: 0x0400022B RID: 555
|
|
public static FOWSystemInterior.OnSaveOrLoad onLoad;
|
|
|
|
// Token: 0x0400022C RID: 556
|
|
public static FOWSystemInterior instance;
|
|
|
|
// Token: 0x0400022D RID: 557
|
|
public static bool readyToCreate = true;
|
|
|
|
// Token: 0x0400022E RID: 558
|
|
private static List<FOWSystemInterior.Revealer> mRevealers = new List<FOWSystemInterior.Revealer>();
|
|
|
|
// Token: 0x0400022F RID: 559
|
|
private static List<FOWSystemInterior.Revealer> mAdded = new List<FOWSystemInterior.Revealer>();
|
|
|
|
// Token: 0x04000230 RID: 560
|
|
private static List<FOWSystemInterior.Revealer> mRemoved = new List<FOWSystemInterior.Revealer>();
|
|
|
|
// Token: 0x04000231 RID: 561
|
|
protected int[,] mHeights;
|
|
|
|
// Token: 0x04000232 RID: 562
|
|
protected Transform mTrans;
|
|
|
|
// Token: 0x04000233 RID: 563
|
|
protected Vector3 mOrigin = Vector3.zero;
|
|
|
|
// Token: 0x04000234 RID: 564
|
|
protected Vector3 mSize = Vector3.one;
|
|
|
|
// Token: 0x04000235 RID: 565
|
|
protected Color32[] mBuffer0;
|
|
|
|
// Token: 0x04000236 RID: 566
|
|
protected Color32[] mBuffer1;
|
|
|
|
// Token: 0x04000237 RID: 567
|
|
protected Color32[] mBuffer2;
|
|
|
|
// Token: 0x04000238 RID: 568
|
|
protected int[] mInteriors;
|
|
|
|
// Token: 0x04000239 RID: 569
|
|
public Texture2D mTexture0;
|
|
|
|
// Token: 0x0400023A RID: 570
|
|
public Texture2D mTexture1;
|
|
|
|
// Token: 0x0400023B RID: 571
|
|
protected float mBlendFactor;
|
|
|
|
// Token: 0x0400023C RID: 572
|
|
protected float mNextUpdate;
|
|
|
|
// Token: 0x0400023D RID: 573
|
|
protected int mScreenHeight;
|
|
|
|
// Token: 0x0400023E RID: 574
|
|
protected FOWSystemInterior.State mState;
|
|
|
|
// Token: 0x0400023F RID: 575
|
|
private Thread mThread;
|
|
|
|
// Token: 0x04000240 RID: 576
|
|
private float mElapsed;
|
|
|
|
// Token: 0x04000241 RID: 577
|
|
[Header("Hannah")]
|
|
public Color unexploredColor = new Color(0f, 0f, 0f, 1f);
|
|
|
|
// Token: 0x04000242 RID: 578
|
|
public Color exploredColor = new Color(0.28627f, 0.28627f, 0.28627f, 1f);
|
|
|
|
// Token: 0x04000243 RID: 579
|
|
public int textureSize = 256;
|
|
|
|
// Token: 0x04000244 RID: 580
|
|
private float updateFrequency = 0.01f;
|
|
|
|
// Token: 0x04000245 RID: 581
|
|
public float textureBlendTime = 0.5f;
|
|
|
|
// Token: 0x04000246 RID: 582
|
|
public int blurIterations = 2;
|
|
|
|
// Token: 0x04000247 RID: 583
|
|
public Vector2 heightRange = new Vector2(0f, 10f);
|
|
|
|
// Token: 0x04000248 RID: 584
|
|
private LayerMask raycastMask = 539165185;
|
|
|
|
// Token: 0x04000249 RID: 585
|
|
public float raycastRadius = 0.1f;
|
|
|
|
// Token: 0x0400024A RID: 586
|
|
public float margin = 0.4f;
|
|
|
|
// Token: 0x0400024B RID: 587
|
|
private bool debug;
|
|
|
|
// Token: 0x0400024C RID: 588
|
|
public int currentInterior;
|
|
|
|
// Token: 0x0400024D RID: 589
|
|
private GameObject interiors;
|
|
|
|
// Token: 0x0400024E RID: 590
|
|
private Transform interiorsTr;
|
|
|
|
// Token: 0x0400024F RID: 591
|
|
private List<Collider> interiorColliders = new List<Collider>();
|
|
|
|
// Token: 0x04000250 RID: 592
|
|
public Transform cameraTarget;
|
|
|
|
// Token: 0x04000251 RID: 593
|
|
private bool loaded;
|
|
|
|
// Token: 0x04000252 RID: 594
|
|
private Camera cam;
|
|
|
|
// Token: 0x04000253 RID: 595
|
|
public bool saveFow = true;
|
|
|
|
// Token: 0x02000125 RID: 293
|
|
public enum LOSChecks
|
|
{
|
|
// Token: 0x04002729 RID: 10025
|
|
None,
|
|
// Token: 0x0400272A RID: 10026
|
|
OnlyOnce,
|
|
// Token: 0x0400272B RID: 10027
|
|
EveryUpdate
|
|
}
|
|
|
|
// Token: 0x02000126 RID: 294
|
|
public class Revealer
|
|
{
|
|
// Token: 0x0400272C RID: 10028
|
|
public bool isValid;
|
|
|
|
// Token: 0x0400272D RID: 10029
|
|
public bool isActive;
|
|
|
|
// Token: 0x0400272E RID: 10030
|
|
public FOWSystemInterior.LOSChecks los;
|
|
|
|
// Token: 0x0400272F RID: 10031
|
|
public Vector3 pos = Vector3.zero;
|
|
|
|
// Token: 0x04002730 RID: 10032
|
|
public float inner;
|
|
|
|
// Token: 0x04002731 RID: 10033
|
|
public float outer;
|
|
|
|
// Token: 0x04002732 RID: 10034
|
|
public bool[] cachedBuffer;
|
|
|
|
// Token: 0x04002733 RID: 10035
|
|
public int cachedSize;
|
|
|
|
// Token: 0x04002734 RID: 10036
|
|
public int cachedX;
|
|
|
|
// Token: 0x04002735 RID: 10037
|
|
public int cachedY;
|
|
}
|
|
|
|
// Token: 0x02000127 RID: 295
|
|
public enum State
|
|
{
|
|
// Token: 0x04002737 RID: 10039
|
|
Blending,
|
|
// Token: 0x04002738 RID: 10040
|
|
NeedUpdate,
|
|
// Token: 0x04002739 RID: 10041
|
|
UpdateTexture0,
|
|
// Token: 0x0400273A RID: 10042
|
|
UpdateTexture1
|
|
}
|
|
|
|
// Token: 0x02000128 RID: 296
|
|
// (Invoke) Token: 0x060016F6 RID: 5878
|
|
public delegate void OnSaveOrLoad();
|
|
}
|