dave/BepInEx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Add source files

Browse Source
This commit is contained in:
PhatPhuckDave
2025-05-21 20:19:45 +02:00
parent 0f2a242b30
commit 71163fc589
284 changed files with 272526 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

170
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/AttackShapes.cs Normal file
View File

@@ -0,0 +1,170 @@
using System;
using UnityEngine;
namespace LOS
{
// Token: 0x02000100 RID: 256
[RequireComponent(typeof(Camera))]
public class AttackShapes : MonoBehaviour
{
// Token: 0x1700001C RID: 28
// (get) Token: 0x060015BD RID: 5565 RVA: 0x0019BC9A File Offset: 0x00199E9A
public static Plane[] CameraFrustumPlanes
{
get
{
return AttackShapes.m_CameraFrustumPlanes;
}
}
// Token: 0x060015BE RID: 5566 RVA: 0x0019BCA1 File Offset: 0x00199EA1
private void Awake()
{
this.m_Camera = base.GetComponent<Camera>();
this.CreateTextures();
}
// Token: 0x060015BF RID: 5567 RVA: 0x0019BCB5 File Offset: 0x00199EB5
private void OnEnable()
{
LOSHelper.ExtractFrustumPlanes(AttackShapes.m_CameraFrustumPlanes, this.m_Camera);
}
// Token: 0x060015C0 RID: 5568 RVA: 0x0019BCC8 File Offset: 0x00199EC8
private void CreateTextures()
{
if (this.textures.Length > 1 && this.textures[1] != null)
{
this.textures[1].Release();
}
if (this.textures[0] != null)
{
this.textures[0].Release();
}
this.textures = new RenderTexture[2];
bool flag = false;
RenderTexture renderTexture = new RenderTexture(this.texSize, this.texSize, 16, RenderTextureFormat.RGHalf);
renderTexture.name = "rt0";
this.textures[0] = renderTexture;
renderTexture.useMipMap = flag;
renderTexture.filterMode = FilterMode.Trilinear;
RenderTexture renderTexture2 = new RenderTexture(this.texSize, this.texSize, 16, RenderTextureFormat.RGHalf);
renderTexture.name = "rt1";
this.textures[1] = renderTexture2;
renderTexture2.useMipMap = flag;
renderTexture2.filterMode = FilterMode.Trilinear;
}
// Token: 0x060015C1 RID: 5569 RVA: 0x0019BD98 File Offset: 0x00199F98
private void OnDisable()
{
}
// Token: 0x060015C2 RID: 5570 RVA: 0x0019BD9C File Offset: 0x00199F9C
private void OnPreRender()
{
if (this.m_Camera == null)
{
return;
}
if (this.textures[0] == null)
{
this.CreateTextures();
}
if (base.transform.hasChanged)
{
LOSHelper.ExtractFrustumPlanes(AttackShapes.m_CameraFrustumPlanes, this.m_Camera);
base.transform.hasChanged = false;
}
}
// Token: 0x060015C3 RID: 5571 RVA: 0x0019BDF8 File Offset: 0x00199FF8
[ImageEffectOpaque]
private void OnRenderImage(RenderTexture source, RenderTexture destination)
{
if (!this.m_Camera)
{
return;
}
Matrix4x4 matrix4x;
Matrix4x4 matrix4x2;
LOSHelper.CalculateViewVectors(this.m_Camera, out matrix4x, out matrix4x2);
Materials.Mask.SetMatrix(ShaderID.FrustumRays, matrix4x);
Materials.Mask.SetMatrix(ShaderID.FrustumOrigins, matrix4x2);
Materials.Mask.SetMatrix(ShaderID.WorldToCameraMatrix, this.m_Camera.worldToCameraMatrix);
Material skybox = RenderSettings.skybox;
RenderSettings.skybox = Materials.SkyBox;
this.RenderSourceToMask(this.caster, 0, this.caster.gameObject.transform.position);
if (this.cameraNumber > 1f)
{
this.RenderSourceToMask(this.caster2, 1, this.caster2.gameObject.transform.position);
}
RenderSettings.skybox = skybox;
if (!this.combineMaterial)
{
this.combineMaterial = new Material(this.coneShader);
}
if (this.caster)
{
this.combineMaterial.SetFloat("cameraLengthConeAttack", this.caster.SourceCamera.farClipPlane);
this.combineMaterial.SetFloat("minVarianceConeAttack", this.caster.MinVariance);
this.combineMaterial.SetFloat("backfaceFadeAttack", this.caster.BackfacesFade);
this.combineMaterial.SetFloat("sphereRadius", this.sphereRadius);
this.combineMaterial.SetFloat("cameraNumber", this.cameraNumber);
}
Graphics.Blit(source, destination, this.combineMaterial, 0);
}
// Token: 0x060015C4 RID: 5572 RVA: 0x0019BF80 File Offset: 0x0019A180
private void RenderSourceToMask(LOSSource losSource, int num, Vector3 center)
{
Camera sourceCamera = losSource.SourceCamera;
Materials.SkyBox.SetVector(ShaderID.FarPlane, new Vector4(sourceCamera.farClipPlane, sourceCamera.farClipPlane, sourceCamera.farClipPlane, sourceCamera.farClipPlane));
sourceCamera.targetTexture = this.textures[num];
sourceCamera.RenderWithShader(Shaders.DepthCone, null);
if (num == 0)
{
Shader.SetGlobalVector("_SourcePosConeAttack", center);
Shader.SetGlobalVector("_LosPosConeAttack", losSource.gameObject.transform.position + losSource.gameObject.transform.forward);
Shader.SetGlobalMatrix("_SourceWorldProjConeAttack", sourceCamera.projectionMatrix * sourceCamera.worldToCameraMatrix);
Shader.SetGlobalMatrix("_Source_CamToWorldConeAttack", sourceCamera.cameraToWorldMatrix);
Shader.SetGlobalTexture("_SourceDepthTexConeAttack", this.textures[num]);
return;
}
Shader.SetGlobalVector("_SourcePosConeAttack1", center);
Shader.SetGlobalVector("_LosPosConeAttack1", losSource.gameObject.transform.position + losSource.gameObject.transform.forward);
Shader.SetGlobalMatrix("_SourceWorldProjConeAttack1", sourceCamera.projectionMatrix * sourceCamera.worldToCameraMatrix);
Shader.SetGlobalTexture("_SourceDepthTexConeAttack1", this.textures[num]);
}
// Token: 0x04002600 RID: 9728
public int texSize = 1024;
// Token: 0x04002601 RID: 9729
public static Plane[] m_CameraFrustumPlanes = new Plane[6];
// Token: 0x04002602 RID: 9730
public LOSSource caster;
// Token: 0x04002603 RID: 9731
public LOSSource caster2;
// Token: 0x04002604 RID: 9732
private Camera m_Camera;
// Token: 0x04002605 RID: 9733
public RenderTexture[] textures = new RenderTexture[1];
// Token: 0x04002606 RID: 9734
private Material combineMaterial;
// Token: 0x04002607 RID: 9735
public float sphereRadius;
// Token: 0x04002608 RID: 9736
public float cameraNumber = 1f;
// Token: 0x04002609 RID: 9737
public Shader coneShader;
}
}

54
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/ILOSSource.cs Normal file
View File

@@ -0,0 +1,54 @@
using System;
using UnityEngine;
namespace LOS
{
// Token: 0x02000101 RID: 257
public interface ILOSSource
{
// Token: 0x1700001D RID: 29
// (get) Token: 0x060015C7 RID: 5575
// (set) Token: 0x060015C8 RID: 5576
Color MaskColor { get; set; }
// Token: 0x1700001E RID: 30
// (get) Token: 0x060015C9 RID: 5577
// (set) Token: 0x060015CA RID: 5578
float MaskIntensity { get; set; }
// Token: 0x1700001F RID: 31
// (get) Token: 0x060015CB RID: 5579
// (set) Token: 0x060015CC RID: 5580
bool MaskInvert { get; set; }
// Token: 0x17000020 RID: 32
// (get) Token: 0x060015CD RID: 5581
// (set) Token: 0x060015CE RID: 5582
float DistanceFade { get; set; }
// Token: 0x17000021 RID: 33
// (get) Token: 0x060015CF RID: 5583
// (set) Token: 0x060015D0 RID: 5584
float MinVariance { get; set; }
// Token: 0x17000022 RID: 34
// (get) Token: 0x060015D1 RID: 5585
bool IsVisible { get; }
// Token: 0x17000023 RID: 35
// (get) Token: 0x060015D2 RID: 5586
Camera SourceCamera { get; }
// Token: 0x17000024 RID: 36
// (get) Token: 0x060015D3 RID: 5587
Bounds CameraBounds { get; }
// Token: 0x17000025 RID: 37
// (get) Token: 0x060015D4 RID: 5588
GameObject GameObject { get; }
// Token: 0x17000026 RID: 38
// (get) Token: 0x060015D5 RID: 5589
Vector4 SourceInfo { get; }
}
}

59
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/LOSBufferStorage.cs Normal file
View File

@@ -0,0 +1,59 @@
using System;
using UnityEngine;
namespace LOS
{
// Token: 0x02000103 RID: 259
[ExecuteInEditMode]
[RequireComponent(typeof(Camera))]
[AddComponentMenu("Line of Sight/LOS Buffer Storage")]
public class LOSBufferStorage : MonoBehaviour
{
// Token: 0x17000028 RID: 40
// (get) Token: 0x060015E0 RID: 5600 RVA: 0x0019C45F File Offset: 0x0019A65F
public RenderTexture BufferTexture
{
get
{
return this.m_Buffer;
}
}
// Token: 0x060015E1 RID: 5601 RVA: 0x0019C467 File Offset: 0x0019A667
private void OnEnable()
{
}
// Token: 0x060015E2 RID: 5602 RVA: 0x0019C469 File Offset: 0x0019A669
private void OnDisable()
{
this.DestroyBuffer();
}
// Token: 0x060015E3 RID: 5603 RVA: 0x0019C474 File Offset: 0x0019A674
private void OnRenderImage(RenderTexture source, RenderTexture destination)
{
if (this.m_Buffer == null || this.m_Buffer.width != source.width || this.m_Buffer.height != source.height || this.m_Buffer.depth != source.depth)
{
this.DestroyBuffer();
this.m_Buffer = new RenderTexture(source.width, source.height, source.depth);
this.m_Buffer.hideFlags = HideFlags.HideAndDontSave;
}
Graphics.Blit(source, this.m_Buffer);
Graphics.Blit(source, destination);
}
// Token: 0x060015E4 RID: 5604 RVA: 0x0019C50B File Offset: 0x0019A70B
private void DestroyBuffer()
{
if (this.m_Buffer != null)
{
Object.DestroyImmediate(this.m_Buffer);
this.m_Buffer = null;
}
}
// Token: 0x04002614 RID: 9748
private RenderTexture m_Buffer;
}
}

70
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/LOSCuller.cs Normal file
View File

@@ -0,0 +1,70 @@
using System;
using System.Collections.Generic;
using UnityEngine;
namespace LOS
{
// Token: 0x02000104 RID: 260
[AddComponentMenu("Line of Sight/LOS Culler")]
public class LOSCuller : MonoBehaviour
{
// Token: 0x17000029 RID: 41
// (get) Token: 0x060015E6 RID: 5606 RVA: 0x0019C535 File Offset: 0x0019A735
// (set) Token: 0x060015E7 RID: 5607 RVA: 0x0019C53D File Offset: 0x0019A73D
public LayerMask RaycastLayerMask
{
get
{
return this.m_RaycastLayerMask;
}
set
{
this.m_RaycastLayerMask = value;
}
}
// Token: 0x1700002A RID: 42
// (get) Token: 0x060015E8 RID: 5608 RVA: 0x0019C546 File Offset: 0x0019A746
public bool Visibile
{
get
{
return this.m_IsVisible;
}
}
// Token: 0x060015E9 RID: 5609 RVA: 0x0019C54E File Offset: 0x0019A74E
private void OnEnable()
{
base.enabled &= Util.Verify(base.GetComponent<Renderer>() != null, "No renderer attached to this GameObject! LOS Culler component must be added to a GameObject containing a MeshRenderer or Skinned Mesh Renderer!");
}
// Token: 0x060015EA RID: 5610 RVA: 0x0019C573 File Offset: 0x0019A773
private void Update()
{
this.m_IsVisible = LOSCuller.CustomCull(base.gameObject.GetComponent<Renderer>().bounds, this.m_RaycastLayerMask.value);
}
// Token: 0x060015EB RID: 5611 RVA: 0x0019C59C File Offset: 0x0019A79C
private static bool CustomCull(Bounds meshBounds, int layerMask)
{
List<LOSSource> lossources = LOSManager.Instance.LOSSources;
for (int i = 0; i < lossources.Count; i++)
{
if (LOSHelper.CheckBoundsVisibility(lossources[i], meshBounds, layerMask))
{
return true;
}
}
return false;
}
// Token: 0x04002615 RID: 9749
[Tooltip("Selects which layers block raycasts used for visibility calculations")]
[SerializeField]
private LayerMask m_RaycastLayerMask = -1;
// Token: 0x04002616 RID: 9750
private bool m_IsVisible = true;
}
}

48
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/LOSFinalResolve.cs Normal file
View File

@@ -0,0 +1,48 @@
using System;
using UnityEngine;
namespace LOS
{
// Token: 0x02000105 RID: 261
[ExecuteInEditMode]
[AddComponentMenu("Line of Sight/Deprecated/LOS Final Resolve")]
public class LOSFinalResolve : MonoBehaviour
{
// Token: 0x060015ED RID: 5613 RVA: 0x0019C5F3 File Offset: 0x0019A7F3
private void OnEnable()
{
Debug.LogWarning("The LOS Final Resolve script component is obsolete, you can safely remove this script.");
}
// Token: 0x060015EE RID: 5614 RVA: 0x0019C5FF File Offset: 0x0019A7FF
private void OnPreRender()
{
if (base.GetComponent<Camera>().actualRenderingPath == RenderingPath.DeferredShading)
{
this.m_ActiveRT = RenderTexture.active;
return;
}
this.m_ActiveRT = null;
}
// Token: 0x060015EF RID: 5615 RVA: 0x0019C624 File Offset: 0x0019A824
private void OnRenderImage(RenderTexture src, RenderTexture dest)
{
if (base.GetComponent<Camera>().actualRenderingPath != RenderingPath.DeferredShading || !this.m_ActiveRT || !(src != this.m_ActiveRT))
{
Graphics.Blit(src, dest);
return;
}
if (src.format == this.m_ActiveRT.format)
{
Graphics.Blit(src, this.m_ActiveRT);
Graphics.Blit(this.m_ActiveRT, dest);
return;
}
Debug.LogWarning("Cant resolve texture, because of different formats!");
}
// Token: 0x04002617 RID: 9751
private RenderTexture m_ActiveRT;
}
}

195
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/LOSHelper.cs Normal file
View File

@@ -0,0 +1,195 @@
using System;
using UnityEngine;
namespace LOS
{
// Token: 0x02000106 RID: 262
public static class LOSHelper
{
// Token: 0x060015F1 RID: 5617 RVA: 0x0019C6A0 File Offset: 0x0019A8A0
public static void ExtractFrustumPlanes(Plane[] planes, Camera camera)
{
Matrix4x4 matrix4x = camera.projectionMatrix * camera.worldToCameraMatrix;
Vector3 vector = new Vector3(matrix4x[3, 0] + matrix4x[0, 0], matrix4x[3, 1] + matrix4x[0, 1], matrix4x[3, 2] + matrix4x[0, 2]);
float num = vector.magnitude;
planes[0].normal = vector.normalized;
planes[0].distance = (matrix4x[3, 3] + matrix4x[0, 3]) / num;
vector = new Vector3(matrix4x[3, 0] - matrix4x[0, 0], matrix4x[3, 1] - matrix4x[0, 1], matrix4x[3, 2] - matrix4x[0, 2]);
num = vector.magnitude;
planes[1].normal = vector.normalized;
planes[1].distance = (matrix4x[3, 3] - matrix4x[0, 3]) / num;
vector = new Vector3(matrix4x[3, 0] + matrix4x[1, 0], matrix4x[3, 1] + matrix4x[1, 1], matrix4x[3, 2] + matrix4x[1, 2]);
num = vector.magnitude;
planes[2].normal = vector.normalized;
planes[2].distance = (matrix4x[3, 3] + matrix4x[1, 3]) / num;
vector = new Vector3(matrix4x[3, 0] - matrix4x[1, 0], matrix4x[3, 1] - matrix4x[1, 1], matrix4x[3, 2] - matrix4x[1, 2]);
num = vector.magnitude;
planes[3].normal = vector.normalized;
planes[3].distance = (matrix4x[3, 3] - matrix4x[1, 3]) / num;
vector = new Vector3(matrix4x[3, 0] + matrix4x[2, 0], matrix4x[3, 1] + matrix4x[2, 1], matrix4x[3, 2] + matrix4x[2, 2]);
num = vector.magnitude;
planes[4].normal = vector.normalized;
planes[4].distance = (matrix4x[3, 3] + matrix4x[2, 3]) / num;
vector = new Vector3(matrix4x[3, 0] - matrix4x[2, 0], matrix4x[3, 1] - matrix4x[2, 1], matrix4x[3, 2] - matrix4x[2, 2]);
num = vector.magnitude;
planes[5].normal = vector.normalized;
planes[5].distance = (matrix4x[3, 3] - matrix4x[2, 3]) / num;
}
// Token: 0x060015F2 RID: 5618 RVA: 0x0019C9A8 File Offset: 0x0019ABA8
public static Matrix4x4 CalculatePerspectiveCorners(Camera currentCamera)
{
float farClipPlane = currentCamera.farClipPlane;
float fieldOfView = currentCamera.fieldOfView;
float aspect = currentCamera.aspect;
Matrix4x4 zero = Matrix4x4.zero;
float num = fieldOfView * 0.5f * 0.017453292f;
float num2 = Mathf.Tan(num) * farClipPlane;
float num3 = Mathf.Tan(num) * aspect * farClipPlane;
Vector3 vector = currentCamera.transform.up * num2;
Vector3 vector2 = currentCamera.transform.right * num3;
Vector3 vector3 = currentCamera.transform.forward * farClipPlane;
Vector3 vector4 = vector3 + vector - vector2;
Vector3 vector5 = vector3 + vector + vector2;
Vector3 vector6 = vector3 - vector + vector2;
Vector3 vector7 = vector3 - vector - vector2;
zero.SetRow(0, vector4);
zero.SetRow(1, vector5);
zero.SetRow(2, vector6);
zero.SetRow(3, vector7);
return zero;
}
// Token: 0x060015F3 RID: 5619 RVA: 0x0019CAA8 File Offset: 0x0019ACA8
public static void CalculateViewVectors(Camera currentCamera, out Matrix4x4 rays, out Matrix4x4 origins)
{
Matrix4x4 inverse = currentCamera.projectionMatrix.inverse;
rays = Matrix4x4.zero;
origins = Matrix4x4.zero;
for (int i = 0; i < 4; i++)
{
Vector4 vector = inverse * LOSHelper.m_NearHomogenousCorners[i];
Vector4 vector2 = inverse * LOSHelper.m_FarHomogenousCorners[i];
vector /= vector.w;
Vector4 vector3 = vector2 / vector2.w - vector;
vector3 /= vector3.z;
Vector4 vector4 = vector - vector3 * vector.z;
vector4.w = 1f;
vector4 = currentCamera.cameraToWorldMatrix * vector4;
vector3 *= -1f;
vector3.w = 0f;
vector3 = currentCamera.cameraToWorldMatrix * vector3;
rays.SetRow(i, vector3);
origins.SetRow(i, vector4);
}
}
// Token: 0x060015F4 RID: 5620 RVA: 0x0019CBAC File Offset: 0x0019ADAC
public static Bounds CalculateSourceBounds(Camera sourceCamera)
{
Matrix4x4 matrix4x = LOSHelper.CalculatePerspectiveCorners(sourceCamera);
Vector3 position = sourceCamera.transform.position;
Vector3 vector = LOSHelper.GetFrustumMin(matrix4x);
vector = Vector3.Min(vector + position, position);
Vector3 vector2 = LOSHelper.GetFrustumMax(matrix4x);
vector2 = Vector3.Max(vector2 + position, position);
Bounds bounds = default(Bounds);
bounds.SetMinMax(vector, vector2);
return bounds;
}
// Token: 0x060015F5 RID: 5621 RVA: 0x0019CC08 File Offset: 0x0019AE08
private static Vector3 GetFrustumMin(Matrix4x4 frustumCorners)
{
Vector3 vector = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
for (int i = 0; i < 4; i++)
{
vector = Vector3.Min(vector, frustumCorners.GetRow(i));
}
return vector;
}
// Token: 0x060015F6 RID: 5622 RVA: 0x0019CC4C File Offset: 0x0019AE4C
private static Vector3 GetFrustumMax(Matrix4x4 frustumCorners)
{
Vector3 vector = new Vector3(float.MinValue, float.MinValue, float.MinValue);
for (int i = 0; i < 4; i++)
{
vector = Vector3.Max(vector, frustumCorners.GetRow(i));
}
return vector;
}
// Token: 0x060015F7 RID: 5623 RVA: 0x0019CC90 File Offset: 0x0019AE90
public static int NearestPowerOfTwo(int value)
{
return (int)Mathf.Pow(2f, (float)Mathf.CeilToInt(Mathf.Log((float)value) / Mathf.Log(2f)));
}
// Token: 0x060015F8 RID: 5624 RVA: 0x0019CCB5 File Offset: 0x0019AEB5
public static void InitSourceCamera(Camera sourceCamera)
{
sourceCamera.enabled = false;
sourceCamera.orthographic = false;
sourceCamera.renderingPath = RenderingPath.VertexLit;
sourceCamera.clearFlags = CameraClearFlags.Skybox;
sourceCamera.allowHDR = false;
sourceCamera.depthTextureMode = DepthTextureMode.None;
}
// Token: 0x060015F9 RID: 5625 RVA: 0x0019CCE4 File Offset: 0x0019AEE4
public static bool CheckBoundsVisibility(LOSSource losSource, Bounds meshBounds, int layerMask)
{
Camera sourceCamera = losSource.SourceCamera;
return losSource.IsVisible && sourceCamera != null && GeometryUtility.TestPlanesAABB(losSource.FrustumPlanes, meshBounds) && LOSHelper.CheckRayCast(sourceCamera, meshBounds, losSource.SourceInfo.w, layerMask);
}
// Token: 0x060015FA RID: 5626 RVA: 0x0019CD30 File Offset: 0x0019AF30
private static bool CheckRayCast(Camera currentCamera, Bounds meshBounds, float maxDistance, int layerMask)
{
bool flag = false;
Vector3 position = currentCamera.transform.position;
if (LOSHelper.CheckRayConnect(meshBounds.center, position, maxDistance, layerMask) || LOSHelper.CheckRayConnect(meshBounds.max, position, maxDistance, layerMask) || LOSHelper.CheckRayConnect(meshBounds.min, position, maxDistance, layerMask))
{
flag = true;
}
return flag;
}
// Token: 0x060015FB RID: 5627 RVA: 0x0019CD84 File Offset: 0x0019AF84
private static bool CheckRayConnect(Vector3 origin, Vector3 cameraPosition, float maxDistance, int layerMask)
{
bool flag = false;
Vector3 vector = origin - cameraPosition;
if (vector.sqrMagnitude < maxDistance * maxDistance)
{
Ray ray = new Ray(cameraPosition, vector);
float num = vector.magnitude - 0.1f;
num = Mathf.Max(1E-05f, num);
if (!Physics.Raycast(ray, num, layerMask))
{
flag = true;
}
}
return flag;
}
// Token: 0x04002618 RID: 9752
private static readonly Vector4[] m_NearHomogenousCorners = new Vector4[]
{
new Vector4(-1f, 1f, -1f, 1f),
new Vector4(1f, 1f, -1f, 1f),
new Vector4(1f, -1f, -1f, 1f),
new Vector4(-1f, -1f, -1f, 1f)
};
// Token: 0x04002619 RID: 9753
private static readonly Vector4[] m_FarHomogenousCorners = new Vector4[]
{
new Vector4(-1f, 1f, 1f, 1f),
new Vector4(1f, 1f, 1f, 1f),
new Vector4(1f, -1f, 1f, 1f),
new Vector4(-1f, -1f, 1f, 1f)
};
}
}

80
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/LOSLayerExcluder.cs Normal file
View File

@@ -0,0 +1,80 @@
using System;
using UnityEngine;
namespace LOS
{
// Token: 0x02000107 RID: 263
[ExecuteInEditMode]
[RequireComponent(typeof(Camera))]
[AddComponentMenu("Line of Sight/LOS Layer Excluder")]
public class LOSLayerExcluder : MonoBehaviour
{
// Token: 0x060015FD RID: 5629 RVA: 0x0019CEF7 File Offset: 0x0019B0F7
private void OnEnable()
{
if (base.GetComponent<Camera>().actualRenderingPath == RenderingPath.DeferredShading)
{
Debug.LogError("The LOS Layer Excluder script component does not support Deferred Rendering!\nPlease use the LOS Stencil Mask script component instead.");
base.enabled = false;
}
}
// Token: 0x060015FE RID: 5630 RVA: 0x0019CF18 File Offset: 0x0019B118
private void Start()
{
this.m_ExcludeCamera = this.CreateExcludeCamera();
}
// Token: 0x060015FF RID: 5631 RVA: 0x0019CF26 File Offset: 0x0019B126
private void LateUpdate()
{
if (this.m_ExcludeCamera)
{
this.SyncCamera(this.m_ExcludeCamera);
}
}
// Token: 0x06001600 RID: 5632 RVA: 0x0019CF44 File Offset: 0x0019B144
private Camera CreateExcludeCamera()
{
GameObject gameObject = null;
Transform transform = base.transform.Find("Exclude Camera");
if (null != transform)
{
gameObject = transform.gameObject;
}
if (null == gameObject)
{
gameObject = new GameObject("Exclude Camera");
gameObject.transform.parent = base.gameObject.transform;
gameObject.transform.localPosition = Vector3.zero;
gameObject.transform.localRotation = Quaternion.identity;
gameObject.transform.localScale = Vector3.one;
}
Camera camera = gameObject.GetComponent<Camera>();
if (null == camera)
{
camera = gameObject.AddComponent<Camera>();
}
return camera;
}
// Token: 0x06001601 RID: 5633 RVA: 0x0019CFE8 File Offset: 0x0019B1E8
private void SyncCamera(Camera excludeCamera)
{
excludeCamera.CopyFrom(base.GetComponent<Camera>());
excludeCamera.cullingMask = this.m_ExcludeLayers.value;
excludeCamera.clearFlags = CameraClearFlags.Nothing;
excludeCamera.depth += 1f;
base.GetComponent<Camera>().cullingMask = base.GetComponent<Camera>().cullingMask & ~this.m_ExcludeLayers.value;
}
// Token: 0x0400261A RID: 9754
[Tooltip("Selects which layers to exclude from the line of sight")]
[SerializeField]
private LayerMask m_ExcludeLayers;
// Token: 0x0400261B RID: 9755
private Camera m_ExcludeCamera;
}
}

127
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/LOSManager.cs Normal file
View File

@@ -0,0 +1,127 @@
using System;
using System.Collections.Generic;
using UnityEngine;
namespace LOS
{
// Token: 0x02000108 RID: 264
public class LOSManager
{
// Token: 0x06001603 RID: 5635 RVA: 0x0019D056 File Offset: 0x0019B256
private LOSManager()
{
}
// Token: 0x1700002B RID: 43
// (get) Token: 0x06001604 RID: 5636 RVA: 0x0019D084 File Offset: 0x0019B284
public static LOSManager Instance
{
get
{
if (LOSManager.m_Instance == null)
{
LOSManager.m_Instance = new LOSManager();
}
return LOSManager.m_Instance;
}
}
// Token: 0x1700002C RID: 44
// (get) Token: 0x06001605 RID: 5637 RVA: 0x0019D09C File Offset: 0x0019B29C
public List<LOSSource> LOSSources
{
get
{
return this.m_LOSSources;
}
}
// Token: 0x1700002D RID: 45
// (get) Token: 0x06001606 RID: 5638 RVA: 0x0019D0A4 File Offset: 0x0019B2A4
public int ActiveCameraCount
{
get
{
int num = 0;
using (List<LOSSource>.Enumerator enumerator = this.m_LOSSources.GetEnumerator())
{
while (enumerator.MoveNext())
{
if (((ILOSSource)enumerator.Current).IsVisible)
{
num++;
}
}
}
return num;
}
}
// Token: 0x1700002E RID: 46
// (get) Token: 0x06001607 RID: 5639 RVA: 0x0019D100 File Offset: 0x0019B300
public int CameraCount
{
get
{
return this.m_LOSSources.Count;
}
}
// Token: 0x06001608 RID: 5640 RVA: 0x0019D10D File Offset: 0x0019B30D
public void AddLOSSource(LOSSource source)
{
this.m_LOSSources.Add(source);
}
// Token: 0x06001609 RID: 5641 RVA: 0x0019D11B File Offset: 0x0019B31B
public void RemoveLOSSource(LOSSource source)
{
this.m_LOSSources.Remove(source);
}
// Token: 0x0600160A RID: 5642 RVA: 0x0019D12C File Offset: 0x0019B32C
public CullingGroup AddCullingGroup(Camera targetCamera)
{
if (!this.m_CullingGroups.ContainsKey(targetCamera))
{
CullingGroup cullingGroup = new CullingGroup();
cullingGroup.targetCamera = targetCamera;
cullingGroup.SetBoundingSpheres(this.m_BoundingSpheres);
this.m_CullingGroups.Add(targetCamera, cullingGroup);
}
return this.m_CullingGroups[targetCamera];
}
// Token: 0x0600160B RID: 5643 RVA: 0x0019D179 File Offset: 0x0019B379
public void RemoveCullingGroup(Camera targetCamera)
{
if (this.m_CullingGroups.ContainsKey(targetCamera))
{
CullingGroup cullingGroup = this.m_CullingGroups[targetCamera];
cullingGroup.onStateChanged = null;
cullingGroup.Dispose();
this.m_CullingGroups.Remove(targetCamera);
}
}
// Token: 0x0600160C RID: 5644 RVA: 0x0019D1B0 File Offset: 0x0019B3B0
private CullingGroup GetCullingGroup(Camera targetCamera)
{
CullingGroup cullingGroup;
this.m_CullingGroups.TryGetValue(targetCamera, out cullingGroup);
return cullingGroup;
}
// Token: 0x0400261C RID: 9756
private static LOSManager m_Instance;
// Token: 0x0400261D RID: 9757
private List<LOSSource> m_LOSSources = new List<LOSSource>();
// Token: 0x0400261E RID: 9758
private BoundingSphere[] m_BoundingSpheres = new BoundingSphere[512];
// Token: 0x0400261F RID: 9759
private Dictionary<Camera, CullingGroup> m_CullingGroups = new Dictionary<Camera, CullingGroup>();
}
}

15
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/LOSQualityLevel.cs Normal file
View File

@@ -0,0 +1,15 @@
using System;
namespace LOS
{
// Token: 0x0200010F RID: 271
public enum LOSQualityLevel
{
// Token: 0x04002647 RID: 9799
Low,
// Token: 0x04002648 RID: 9800
Medium,
// Token: 0x04002649 RID: 9801
High
}
}

449
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/LOSSource.cs Normal file
View File

@@ -0,0 +1,449 @@
using System;
using UnityEngine;
namespace LOS
{
// Token: 0x0200010D RID: 269
[ExecuteInEditMode]
[RequireComponent(typeof(Camera))]
[AddComponentMenu("Line of Sight/LOS Source")]
public class LOSSource : MonoBehaviour, ILOSSource
{
// Token: 0x17000046 RID: 70
// (get) Token: 0x0600162C RID: 5676 RVA: 0x0019D4E8 File Offset: 0x0019B6E8
// (set) Token: 0x0600162D RID: 5677 RVA: 0x0019D4F0 File Offset: 0x0019B6F0
public Color MaskColor
{
get
{
return this.m_MaskColor;
}
set
{
this.m_MaskColor = value;
}
}
// Token: 0x17000047 RID: 71
// (get) Token: 0x0600162E RID: 5678 RVA: 0x0019D4F9 File Offset: 0x0019B6F9
// (set) Token: 0x0600162F RID: 5679 RVA: 0x0019D501 File Offset: 0x0019B701
public float MaskIntensity
{
get
{
return this.m_MaskIntensity;
}
set
{
this.m_MaskIntensity = value;
}
}
// Token: 0x17000048 RID: 72
// (get) Token: 0x06001630 RID: 5680 RVA: 0x0019D50A File Offset: 0x0019B70A
// (set) Token: 0x06001631 RID: 5681 RVA: 0x0019D512 File Offset: 0x0019B712
public bool MaskInvert
{
get
{
return this.m_MaskInvert;
}
set
{
this.m_MaskInvert = value;
}
}
// Token: 0x17000049 RID: 73
// (get) Token: 0x06001632 RID: 5682 RVA: 0x0019D51B File Offset: 0x0019B71B
// (set) Token: 0x06001633 RID: 5683 RVA: 0x0019D523 File Offset: 0x0019B723
public int RenderTargetWidth
{
get
{
return this.m_RenderTargetWidth;
}
set
{
this.m_RenderTargetWidth = Mathf.Clamp(value, 1, 4096);
}
}
// Token: 0x1700004A RID: 74
// (get) Token: 0x06001634 RID: 5684 RVA: 0x0019D537 File Offset: 0x0019B737
// (set) Token: 0x06001635 RID: 5685 RVA: 0x0019D53F File Offset: 0x0019B73F
public int RenderTargetHeight
{
get
{
return this.m_RenderTargetHeight;
}
set
{
this.m_RenderTargetHeight = Mathf.Clamp(value, 1, 4096);
}
}
// Token: 0x1700004B RID: 75
// (get) Token: 0x06001636 RID: 5686 RVA: 0x0019D553 File Offset: 0x0019B753
// (set) Token: 0x06001637 RID: 5687 RVA: 0x0019D55B File Offset: 0x0019B75B
public float DistanceFade
{
get
{
return this.m_DistanceFade;
}
set
{
this.m_DistanceFade = Mathf.Clamp01(value);
}
}
// Token: 0x1700004C RID: 76
// (get) Token: 0x06001638 RID: 5688 RVA: 0x0019D569 File Offset: 0x0019B769
// (set) Token: 0x06001639 RID: 5689 RVA: 0x0019D571 File Offset: 0x0019B771
public float EdgeFade
{
get
{
return this.m_EdgeFade;
}
set
{
this.m_EdgeFade = Mathf.Clamp01(value);
}
}
// Token: 0x1700004D RID: 77
// (get) Token: 0x0600163A RID: 5690 RVA: 0x0019D57F File Offset: 0x0019B77F
// (set) Token: 0x0600163B RID: 5691 RVA: 0x0019D587 File Offset: 0x0019B787
public bool ExcludeBackfaces
{
get
{
return this.m_ExcludeBackfaces;
}
set
{
this.m_ExcludeBackfaces = value;
}
}
// Token: 0x1700004E RID: 78
// (get) Token: 0x0600163C RID: 5692 RVA: 0x0019D590 File Offset: 0x0019B790
// (set) Token: 0x0600163D RID: 5693 RVA: 0x0019D598 File Offset: 0x0019B798
public float BackfacesFade
{
get
{
return this.m_BackfacesFade;
}
set
{
this.m_BackfacesFade = value;
}
}
// Token: 0x1700004F RID: 79
// (get) Token: 0x0600163E RID: 5694 RVA: 0x0019D5A1 File Offset: 0x0019B7A1
// (set) Token: 0x0600163F RID: 5695 RVA: 0x0019D5A9 File Offset: 0x0019B7A9
public float MinVariance
{
get
{
return this.m_MinVariance;
}
set
{
this.m_MinVariance = Mathf.Clamp01(value);
}
}
// Token: 0x17000050 RID: 80
// (get) Token: 0x06001640 RID: 5696 RVA: 0x0019D5B7 File Offset: 0x0019B7B7
// (set) Token: 0x06001641 RID: 5697 RVA: 0x0019D5BF File Offset: 0x0019B7BF
public PixelOperation OutOfBoundArea
{
get
{
return this.m_OutOfBoundArea;
}
set
{
this.m_OutOfBoundArea = value;
}
}
// Token: 0x17000051 RID: 81
// (get) Token: 0x06001642 RID: 5698 RVA: 0x0019D5C8 File Offset: 0x0019B7C8
public Camera SourceCamera
{
get
{
return this.m_Camera;
}
}
// Token: 0x17000052 RID: 82
// (get) Token: 0x06001643 RID: 5699 RVA: 0x0019D5D0 File Offset: 0x0019B7D0
public Bounds CameraBounds
{
get
{
return this.m_CameraBounds;
}
}
// Token: 0x17000053 RID: 83
// (get) Token: 0x06001644 RID: 5700 RVA: 0x0019D5D8 File Offset: 0x0019B7D8
public GameObject GameObject
{
get
{
return base.gameObject;
}
}
// Token: 0x17000054 RID: 84
// (get) Token: 0x06001645 RID: 5701 RVA: 0x0019D5E0 File Offset: 0x0019B7E0
public Plane[] FrustumPlanes
{
get
{
return this.m_FrustumPlanes;
}
}
// Token: 0x17000055 RID: 85
// (get) Token: 0x06001646 RID: 5702 RVA: 0x0019D5E8 File Offset: 0x0019B7E8
public Vector4 SourceInfo
{
get
{
Vector4 vector = Vector4.zero;
if (this.m_Camera != null)
{
vector = this.m_Camera.transform.position;
vector.w = this.m_Camera.farClipPlane;
}
return vector;
}
}
// Token: 0x17000056 RID: 86
// (get) Token: 0x06001647 RID: 5703 RVA: 0x0019D632 File Offset: 0x0019B832
public bool IsVisible
{
get
{
return this.m_IsVisibile;
}
}
// Token: 0x06001648 RID: 5704 RVA: 0x0019D63A File Offset: 0x0019B83A
private void Awake()
{
this.m_Camera = base.GetComponent<Camera>();
}
// Token: 0x06001649 RID: 5705 RVA: 0x0019D648 File Offset: 0x0019B848
public void SetCamera(Camera cam)
{
this.m_Camera = cam;
}
// Token: 0x0600164A RID: 5706 RVA: 0x0019D654 File Offset: 0x0019B854
private void OnEnable()
{
LOSManager.Instance.AddLOSSource(this);
this.m_Camera = base.GetComponent<Camera>();
base.enabled &= Util.Verify(this.m_Camera != null, "Camera Component missing");
if (base.enabled)
{
LOSHelper.InitSourceCamera(this.m_Camera);
this.m_CameraBounds = LOSHelper.CalculateSourceBounds(this.m_Camera);
LOSHelper.ExtractFrustumPlanes(this.m_FrustumPlanes, this.m_Camera);
}
this.m_IsVisibile = true;
}
// Token: 0x0600164B RID: 5707 RVA: 0x0019D6D7 File Offset: 0x0019B8D7
private void OnDisable()
{
LOSManager.Instance.RemoveLOSSource(this);
}
// Token: 0x0600164C RID: 5708 RVA: 0x0019D6E4 File Offset: 0x0019B8E4
public Matrix4x4 CalculatePerspectiveCorners(Camera currentCamera)
{
float farClipPlane = currentCamera.farClipPlane;
float fieldOfView = currentCamera.fieldOfView;
float aspect = currentCamera.aspect;
Matrix4x4 zero = Matrix4x4.zero;
float num = fieldOfView * 0.5f * 0.017453292f;
float num2 = Mathf.Tan(num) * farClipPlane;
float num3 = Mathf.Tan(num) * aspect * farClipPlane;
Vector3 vector = currentCamera.transform.up * num2;
Vector3 vector2 = currentCamera.transform.right * num3;
Vector3 vector3 = currentCamera.transform.forward * farClipPlane;
Vector3 vector4 = vector3 + vector - vector2;
Vector3 vector5 = vector3 + vector + vector2;
Vector3 vector6 = vector3 - vector + vector2;
Vector3 vector7 = vector3 - vector - vector2;
zero.SetRow(0, vector4);
zero.SetRow(1, vector5);
zero.SetRow(2, vector6);
zero.SetRow(3, vector7);
return zero;
}
// Token: 0x0600164D RID: 5709 RVA: 0x0019D7E4 File Offset: 0x0019B9E4
public Bounds CalculateSourceBounds()
{
Matrix4x4 matrix4x = this.CalculatePerspectiveCorners(this.m_Camera);
Vector3 position = this.m_Camera.transform.position;
Vector3 vector = this.GetFrustumMin(matrix4x);
vector = Vector3.Min(vector + position, position);
Vector3 vector2 = this.GetFrustumMax(matrix4x);
vector2 = Vector3.Max(vector2 + position, position);
Bounds bounds = default(Bounds);
bounds.SetMinMax(vector, vector2);
return bounds;
}
// Token: 0x0600164E RID: 5710 RVA: 0x0019D850 File Offset: 0x0019BA50
private Vector3 GetFrustumMin(Matrix4x4 frustumCorners)
{
Vector3 vector = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
for (int i = 0; i < 4; i++)
{
vector = Vector3.Min(vector, frustumCorners.GetRow(i));
}
return vector;
}
// Token: 0x0600164F RID: 5711 RVA: 0x0019D894 File Offset: 0x0019BA94
private Vector3 GetFrustumMax(Matrix4x4 frustumCorners)
{
Vector3 vector = new Vector3(float.MinValue, float.MinValue, float.MinValue);
for (int i = 0; i < 4; i++)
{
vector = Vector3.Max(vector, frustumCorners.GetRow(i));
}
return vector;
}
// Token: 0x06001650 RID: 5712 RVA: 0x0019D8D8 File Offset: 0x0019BAD8
public void ExtractFrustumPlanes(Camera camera)
{
Matrix4x4 matrix4x = camera.projectionMatrix * camera.worldToCameraMatrix;
Vector3 vector = new Vector3(matrix4x[3, 0] + matrix4x[0, 0], matrix4x[3, 1] + matrix4x[0, 1], matrix4x[3, 2] + matrix4x[0, 2]);
float num = vector.magnitude;
this.m_FrustumPlanes[0].normal = vector.normalized;
this.m_FrustumPlanes[0].distance = (matrix4x[3, 3] + matrix4x[0, 3]) / num;
vector = new Vector3(matrix4x[3, 0] - matrix4x[0, 0], matrix4x[3, 1] - matrix4x[0, 1], matrix4x[3, 2] - matrix4x[0, 2]);
num = vector.magnitude;
this.m_FrustumPlanes[1].normal = vector.normalized;
this.m_FrustumPlanes[1].distance = (matrix4x[3, 3] - matrix4x[0, 3]) / num;
vector = new Vector3(matrix4x[3, 0] + matrix4x[1, 0], matrix4x[3, 1] + matrix4x[1, 1], matrix4x[3, 2] + matrix4x[1, 2]);
num = vector.magnitude;
this.m_FrustumPlanes[2].normal = vector.normalized;
this.m_FrustumPlanes[2].distance = (matrix4x[3, 3] + matrix4x[1, 3]) / num;
vector = new Vector3(matrix4x[3, 0] - matrix4x[1, 0], matrix4x[3, 1] - matrix4x[1, 1], matrix4x[3, 2] - matrix4x[1, 2]);
num = vector.magnitude;
this.m_FrustumPlanes[3].normal = vector.normalized;
this.m_FrustumPlanes[3].distance = (matrix4x[3, 3] - matrix4x[1, 3]) / num;
vector = new Vector3(matrix4x[3, 0] + matrix4x[2, 0], matrix4x[3, 1] + matrix4x[2, 1], matrix4x[3, 2] + matrix4x[2, 2]);
num = vector.magnitude;
this.m_FrustumPlanes[4].normal = vector.normalized;
this.m_FrustumPlanes[4].distance = (matrix4x[3, 3] + matrix4x[2, 3]) / num;
vector = new Vector3(matrix4x[3, 0] - matrix4x[2, 0], matrix4x[3, 1] - matrix4x[2, 1], matrix4x[3, 2] - matrix4x[2, 2]);
num = vector.magnitude;
this.m_FrustumPlanes[5].normal = vector.normalized;
this.m_FrustumPlanes[5].distance = (matrix4x[3, 3] - matrix4x[2, 3]) / num;
}
// Token: 0x04002635 RID: 9781
private const int MIN_TEXTURE_SIZE = 1;
// Token: 0x04002636 RID: 9782
private const int MAX_TEXTURE_SIZE = 4096;
// Token: 0x04002637 RID: 9783
[Header("Mask Settings", order = 0)]
[Tooltip("Color rendered into mask")]
[SerializeField]
private Color m_MaskColor = Color.white;
// Token: 0x04002638 RID: 9784
[Tooltip("Intensity of color rendered into mask")]
[Range(0f, 10f)]
[SerializeField]
private float m_MaskIntensity = 1f;
// Token: 0x04002639 RID: 9785
[Tooltip("Inverts mask")]
[SerializeField]
private bool m_MaskInvert;
// Token: 0x0400263A RID: 9786
[Header("Render Target Settings", order = 1)]
[Tooltip("Width of target render texture")]
[SerializeField]
private int m_RenderTargetWidth = 512;
// Token: 0x0400263B RID: 9787
[Tooltip("Height of target render texture")]
[SerializeField]
private int m_RenderTargetHeight = 512;
// Token: 0x0400263C RID: 9788
[Header("Fade Settings", order = 2)]
[Tooltip("Fade over distance amount")]
[Range(0f, 1f)]
[SerializeField]
private float m_DistanceFade = 0.1f;
// Token: 0x0400263D RID: 9789
[Tooltip("Edge fade amount")]
[Range(0f, 1f)]
[SerializeField]
private float m_EdgeFade = 0.1f;
// Token: 0x0400263E RID: 9790
[Header("Backface Settings", order = 4)]
[Tooltip("Excludes backfacing faces from mask")]
[SerializeField]
private bool m_ExcludeBackfaces = true;
// Token: 0x0400263F RID: 9791
[Tooltip("Fades the edge of the backface transition in the mask")]
[Range(0f, 1f)]
[SerializeField]
private float m_BackfacesFade = 0.1f;
// Token: 0x04002640 RID: 9792
[Header("Advanced Settings", order = 4)]
[Tooltip("Reduces artifacts in mask, similar to shadow bias setting")]
[Range(0f, 1f)]
[SerializeField]
private float m_MinVariance = 0.1f;
// Token: 0x04002641 RID: 9793
[Tooltip("Sets how pixels above and below the cameras frustum are handled")]
[SerializeField]
private PixelOperation m_OutOfBoundArea;
// Token: 0x04002642 RID: 9794
private Plane[] m_FrustumPlanes = new Plane[6];
// Token: 0x04002643 RID: 9795
private Camera m_Camera;
// Token: 0x04002644 RID: 9796
private Bounds m_CameraBounds;
// Token: 0x04002645 RID: 9797
private bool m_IsVisibile = true;
}
}

150
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/LineOfSightCone.cs Normal file
View File

@@ -0,0 +1,150 @@
using System;
using UnityEngine;
namespace LOS
{
// Token: 0x02000102 RID: 258
[RequireComponent(typeof(Camera))]
public class LineOfSightCone : MonoBehaviour
{
// Token: 0x17000027 RID: 39
// (get) Token: 0x060015D6 RID: 5590 RVA: 0x0019C10A File Offset: 0x0019A30A
public static Plane[] CameraFrustumPlanes
{
get
{
return LineOfSightCone.m_CameraFrustumPlanes;
}
}
// Token: 0x060015D7 RID: 5591 RVA: 0x0019C111 File Offset: 0x0019A311
private void Awake()
{
this.m_Camera = base.GetComponent<Camera>();
this.CreateTextures();
}
// Token: 0x060015D8 RID: 5592 RVA: 0x0019C125 File Offset: 0x0019A325
private void OnEnable()
{
LOSHelper.ExtractFrustumPlanes(LineOfSightCone.m_CameraFrustumPlanes, this.m_Camera);
}
// Token: 0x060015D9 RID: 5593 RVA: 0x0019C138 File Offset: 0x0019A338
private void CreateTextures()
{
this.width = Screen.width;
this.height = Screen.height;
if (this.textures[0] != null)
{
this.textures[0].Release();
}
this.textures = new RenderTexture[1];
bool flag = false;
RenderTexture renderTexture = new RenderTexture(this.texSize, this.texSize, 16, RenderTextureFormat.RGHalf);
renderTexture.name = "rt0";
this.textures[0] = renderTexture;
renderTexture.useMipMap = flag;
renderTexture.filterMode = FilterMode.Trilinear;
}
// Token: 0x060015DA RID: 5594 RVA: 0x0019C1BE File Offset: 0x0019A3BE
private void OnDisable()
{
}
// Token: 0x060015DB RID: 5595 RVA: 0x0019C1C0 File Offset: 0x0019A3C0
private void OnPreRender()
{
if (this.m_Camera == null)
{
return;
}
if (this.textures[0] == null)
{
this.CreateTextures();
}
if (base.transform.hasChanged)
{
LOSHelper.ExtractFrustumPlanes(LineOfSightCone.m_CameraFrustumPlanes, this.m_Camera);
base.transform.hasChanged = false;
}
}
// Token: 0x060015DC RID: 5596 RVA: 0x0019C21C File Offset: 0x0019A41C
[ImageEffectOpaque]
private void OnRenderImage(RenderTexture source, RenderTexture destination)
{
if (!this.m_Camera)
{
return;
}
Matrix4x4 matrix4x;
Matrix4x4 matrix4x2;
LOSHelper.CalculateViewVectors(this.m_Camera, out matrix4x, out matrix4x2);
Materials.Mask.SetMatrix(ShaderID.FrustumRays, matrix4x);
Materials.Mask.SetMatrix(ShaderID.FrustumOrigins, matrix4x2);
Materials.Mask.SetMatrix(ShaderID.WorldToCameraMatrix, this.m_Camera.worldToCameraMatrix);
Material skybox = RenderSettings.skybox;
RenderSettings.skybox = Materials.SkyBox;
this.RenderSourceToMask(this.caster, 0, this.caster.gameObject.transform.position);
RenderSettings.skybox = skybox;
if (!this.combineMaterial)
{
this.combineMaterial = new Material(this.coneShader);
}
if (this.caster)
{
this.combineMaterial.SetFloat("cameraLengthCone", this.caster.SourceCamera.farClipPlane);
this.combineMaterial.SetFloat("minVarianceCone", this.caster.MinVariance);
this.combineMaterial.SetFloat("backfaceFade", this.caster.BackfacesFade);
}
Shader.SetGlobalTexture("_SourceDepthTexCone", this.textures[0]);
Graphics.Blit(source, destination, this.combineMaterial, 0);
}
// Token: 0x060015DD RID: 5597 RVA: 0x0019C358 File Offset: 0x0019A558
private void RenderSourceToMask(LOSSource losSource, int num, Vector3 center)
{
Camera sourceCamera = losSource.SourceCamera;
Materials.SkyBox.SetVector(ShaderID.FarPlane, new Vector4(sourceCamera.farClipPlane, sourceCamera.farClipPlane, sourceCamera.farClipPlane, sourceCamera.farClipPlane));
sourceCamera.targetTexture = this.textures[num];
sourceCamera.RenderWithShader(Shaders.DepthCone, null);
Shader.SetGlobalVector("_SourcePosCone", center);
Shader.SetGlobalVector("_LosPosCone", losSource.gameObject.transform.position + losSource.gameObject.transform.forward);
Shader.SetGlobalMatrix("_SourceWorldProjCone", sourceCamera.projectionMatrix * sourceCamera.worldToCameraMatrix);
Shader.SetGlobalMatrix("_Source_CamToWorldCone", sourceCamera.cameraToWorldMatrix);
Shader.SetGlobalTexture("_SourceDepthTexCone", this.textures[num]);
}
// Token: 0x0400260A RID: 9738
public int texSize = 1024;
// Token: 0x0400260B RID: 9739
public static Plane[] m_CameraFrustumPlanes = new Plane[6];
// Token: 0x0400260C RID: 9740
public LOSSource caster;
// Token: 0x0400260D RID: 9741
public LOSSource caster2;
// Token: 0x0400260E RID: 9742
private Camera m_Camera;
// Token: 0x0400260F RID: 9743
public RenderTexture[] textures = new RenderTexture[1];
// Token: 0x04002610 RID: 9744
private Material combineMaterial;
// Token: 0x04002611 RID: 9745
private int width;
// Token: 0x04002612 RID: 9746
private int height;
// Token: 0x04002613 RID: 9747
public Shader coneShader;
}
}

177
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/Materials.cs Normal file
View File

@@ -0,0 +1,177 @@
using System;
using UnityEngine;
namespace LOS
{
// Token: 0x02000109 RID: 265
public class Materials
{
// Token: 0x1700002F RID: 47
// (get) Token: 0x0600160D RID: 5645 RVA: 0x0019D1CD File Offset: 0x0019B3CD
public static Material Mask
{
get
{
if (Materials.m_MaskMaterial == null)
{
Materials.m_MaskMaterial = Materials.CreateMaterial("Shaders/LOSMask");
}
return Materials.m_MaskMaterial;
}
}
// Token: 0x17000030 RID: 48
// (get) Token: 0x0600160E RID: 5646 RVA: 0x0019D1F0 File Offset: 0x0019B3F0
public static Material Combine
{
get
{
if (Materials.m_CombineMaterial == null)
{
Materials.m_CombineMaterial = Materials.CreateMaterial("Shaders/LOSCombine");
}
return Materials.m_CombineMaterial;
}
}
// Token: 0x17000031 RID: 49
// (get) Token: 0x0600160F RID: 5647 RVA: 0x0019D213 File Offset: 0x0019B413
public static Material SkyBox
{
get
{
if (Materials.m_SkyBoxMaterial == null)
{
Materials.m_SkyBoxMaterial = Materials.CreateMaterial("Shaders/LOSSkyBox");
}
return Materials.m_SkyBoxMaterial;
}
}
// Token: 0x17000032 RID: 50
// (get) Token: 0x06001610 RID: 5648 RVA: 0x0019D236 File Offset: 0x0019B436
public static Material StencilRenderer
{
get
{
if (Materials.m_StencilRenderer == null)
{
Materials.m_StencilRenderer = Materials.CreateMaterial("Shaders/LOSStencilRenderer");
}
return Materials.m_StencilRenderer;
}
}
// Token: 0x17000033 RID: 51
// (get) Token: 0x06001611 RID: 5649 RVA: 0x0019D259 File Offset: 0x0019B459
public static Material StencilMask
{
get
{
if (Materials.m_StencilMask == null)
{
Materials.m_StencilMask = Materials.CreateMaterial("Shaders/LOSStencilMask");
}
return Materials.m_StencilMask;
}
}
// Token: 0x17000034 RID: 52
// (get) Token: 0x06001612 RID: 5650 RVA: 0x0019D27C File Offset: 0x0019B47C
public static Material Debug
{
get
{
if (Materials.m_Debug == null)
{
Materials.m_Debug = Materials.CreateMaterial("Shaders/LOSDebug");
}
return Materials.m_Debug;
}
}
// Token: 0x06001613 RID: 5651 RVA: 0x0019D2A0 File Offset: 0x0019B4A0
public static void DestroyResources()
{
if (Materials.m_MaskMaterial != null)
{
Object.DestroyImmediate(Materials.m_MaskMaterial);
Materials.m_MaskMaterial = null;
}
if (Materials.m_CombineMaterial != null)
{
Object.DestroyImmediate(Materials.m_CombineMaterial);
Materials.m_CombineMaterial = null;
}
if (Materials.m_SkyBoxMaterial != null)
{
Object.DestroyImmediate(Materials.m_SkyBoxMaterial);
Materials.m_SkyBoxMaterial = null;
}
if (Materials.m_StencilRenderer != null)
{
Object.DestroyImmediate(Materials.m_StencilRenderer);
Materials.m_StencilRenderer = null;
}
if (Materials.m_StencilMask != null)
{
Object.DestroyImmediate(Materials.m_StencilMask);
Materials.m_StencilMask = null;
}
if (Materials.m_Debug != null)
{
Object.DestroyImmediate(Materials.m_Debug);
Materials.m_Debug = null;
}
}
// Token: 0x06001614 RID: 5652 RVA: 0x0019D35C File Offset: 0x0019B55C
private static Material CreateMaterial(string shaderResource)
{
Material material = null;
Shader shader = Resources.Load(shaderResource, typeof(Shader)) as Shader;
if (Util.Verify(Shaders.CheckShader(shader)))
{
material = new Material(shader);
material.hideFlags = HideFlags.HideAndDontSave;
}
return material;
}
// Token: 0x04002620 RID: 9760
private const string MaskShaderPath = "Shaders/LOSMask";
// Token: 0x04002621 RID: 9761
private const string CombineShaderPath = "Shaders/LOSCombine";
// Token: 0x04002622 RID: 9762
private const string SkyBoxShaderPath = "Shaders/LOSSkyBox";
// Token: 0x04002623 RID: 9763
private const string StencilRendererShaderPath = "Shaders/LOSStencilRenderer";
// Token: 0x04002624 RID: 9764
private const string StencilMaskShaderPath = "Shaders/LOSStencilMask";
// Token: 0x04002625 RID: 9765
private const string DebugShaderPath = "Shaders/LOSDebug";
// Token: 0x04002626 RID: 9766
private static Material m_MaskMaterial;
// Token: 0x04002627 RID: 9767
private static Material m_CombineMaterial;
// Token: 0x04002628 RID: 9768
private static Material m_SkyBoxMaterial;
// Token: 0x04002629 RID: 9769
private static Material m_StencilRenderer;
// Token: 0x0400262A RID: 9770
private static Material m_StencilMask;
// Token: 0x0400262B RID: 9771
private static Material m_Debug;
}
}

15
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/PixelOperation.cs Normal file
View File

@@ -0,0 +1,15 @@
using System;
namespace LOS
{
// Token: 0x0200010C RID: 268
public enum PixelOperation
{
// Token: 0x04002632 RID: 9778
Clamp,
// Token: 0x04002633 RID: 9779
Include,
// Token: 0x04002634 RID: 9780
Exclude
}
}

381
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/PointLightShadows.cs Normal file
View File

@@ -0,0 +1,381 @@
using System;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;
using UnityEngine.Rendering;
namespace LOS
{
// Token: 0x02000110 RID: 272
[RequireComponent(typeof(Camera))]
public class PointLightShadows : MonoBehaviour
{
// Token: 0x17000057 RID: 87
// (get) Token: 0x06001655 RID: 5717 RVA: 0x0019DCAF File Offset: 0x0019BEAF
public static Plane[] CameraFrustumPlanes
{
get
{
return PointLightShadows.m_CameraFrustumPlanes;
}
}
// Token: 0x06001656 RID: 5718 RVA: 0x0019DCB6 File Offset: 0x0019BEB6
private void Awake()
{
this.m_Camera = base.GetComponent<Camera>();
this.pointLightObject.SetActive(false);
}
// Token: 0x06001657 RID: 5719 RVA: 0x0019DCD0 File Offset: 0x0019BED0
private void OnEnable()
{
LOSHelper.ExtractFrustumPlanes(PointLightShadows.m_CameraFrustumPlanes, this.m_Camera);
}
// Token: 0x06001658 RID: 5720 RVA: 0x0019DCE2 File Offset: 0x0019BEE2
private void OnDisable()
{
Materials.DestroyResources();
Shaders.DestroyResources();
if (this.buffer != null)
{
this.m_Camera.RemoveCommandBuffer(CameraEvent.AfterDepthTexture, this.buffer);
}
}
// Token: 0x06001659 RID: 5721 RVA: 0x0019DD08 File Offset: 0x0019BF08
private void CreateCombineTexture()
{
this.width = Screen.width;
this.height = Screen.height;
if (this.combinedLights)
{
this.combinedLights.Release();
}
this.combinedLights = new RenderTexture(this.width, this.height, 16, RenderTextureFormat.R8);
if (this.combinedLights2)
{
this.combinedLights2.Release();
}
this.combinedLights2 = new RenderTexture(this.width, this.height, 16, RenderTextureFormat.R8);
}
// Token: 0x0600165A RID: 5722 RVA: 0x0019DD91 File Offset: 0x0019BF91
private float GetCamDistance(int id)
{
if (id < this.cameraDistance.Count)
{
return this.cameraDistance[id];
}
return 0f;
}
// Token: 0x0600165B RID: 5723 RVA: 0x0019DDB3 File Offset: 0x0019BFB3
private Vector3 GetCamPosition(int id)
{
if (id < this.cameraPosition.Count)
{
return this.cameraPosition[id];
}
return Vector3.zero;
}
// Token: 0x0600165C RID: 5724 RVA: 0x0019DDD8 File Offset: 0x0019BFD8
public void Buffer()
{
if (this.buffer == null)
{
this.buffer = new CommandBuffer();
this.buffer.name = "Quad Shadows";
this.m_Camera.AddCommandBuffer(CameraEvent.AfterDepthTexture, this.buffer);
}
this.buffer.Clear();
if (Links.x && Links.x.cameraEffects)
{
if (this.quadW != Screen.width || this.quadH != Screen.height || !this.quadShadowTexture)
{
if (this.quadShadowTexture)
{
this.quadShadowTexture.Release();
}
if (this.quadShadowTextureFinal)
{
this.quadShadowTextureFinal.Release();
}
this.quadW = Screen.width;
this.quadH = Screen.height;
this.quadShadowTexture = new RenderTexture(this.quadW, this.quadH, 16, RenderTextureFormat.R8);
}
RenderTargetIdentifier renderTargetIdentifier = new RenderTargetIdentifier(this.quadShadowTexture);
this.buffer.SetRenderTarget(renderTargetIdentifier);
this.buffer.ClearRenderTarget(true, true, Color.clear);
if (!this.switchingScenes)
{
for (int i = 0; i < this.quadsToRender.Count; i++)
{
if (this.quadsToRender[i])
{
if (!Links.x.cameraEffects.indoors)
{
this.buffer.DrawRenderer(this.quadsToRender[i], this.quadMats[i], 0, 0);
}
else
{
this.buffer.DrawRenderer(this.quadsToRender[i], this.quadMats[i], 0, 0);
}
}
}
}
this.buffer.SetGlobalTexture("_QuadShadows", this.quadShadowTexture);
}
}
// Token: 0x0600165D RID: 5725 RVA: 0x0019DFAC File Offset: 0x0019C1AC
public void SwitchingScenes()
{
Shader.SetGlobalTexture("_RealtimeShadowTex", Links.x.emptyTexture);
this.switchingScenes = true;
for (int i = 0; i < this.quadMats.Count; i++)
{
Object.Destroy(this.quadMats[i]);
}
this.quadMats.Clear();
this.quadsToRender.Clear();
}
// Token: 0x0600165E RID: 5726 RVA: 0x0019E011 File Offset: 0x0019C211
public void DoneSwitchingScenes()
{
this.switchingScenes = false;
}
// Token: 0x0600165F RID: 5727 RVA: 0x0019E01A File Offset: 0x0019C21A
private void OnPreRender()
{
if (this.width != Screen.width || this.height != Screen.height)
{
this.CreateCombineTexture();
}
this.Buffer();
}
// Token: 0x06001660 RID: 5728 RVA: 0x0019E044 File Offset: 0x0019C244
private void Update()
{
if (Links.x && Links.x.diorama)
{
if (this.quads == null)
{
this.quads = Links.x.quads;
}
if (this.quads != null && !this.switchingScenes)
{
this.quadsToRender.Clear();
int num = 0;
int count = this.quads.Count;
this.planes = GeometryUtility.CalculateFrustumPlanes(Links.x.worldCamera);
for (int i = 0; i < count; i++)
{
if (this.quads[i].isOn)
{
MeshRenderer art = this.quads[i].art;
if (art && art.enabled && this.TestPlanesAABBInternalFastBounds(this.quads[i].art.bounds.min, this.quads[i].art.bounds.max))
{
this.quadsToRender.Add(art);
if (this.quadMats.Count < this.quadsToRender.Count)
{
Material material = new Material(this.quadShader);
this.quadMats.Add(material);
}
else
{
Material material2 = this.quadMats[num];
}
num++;
}
}
}
}
}
}
// Token: 0x06001661 RID: 5729 RVA: 0x0019E1B9 File Offset: 0x0019C3B9
public void SetupNewInterior(InteriorLights l)
{
}
// Token: 0x06001662 RID: 5730 RVA: 0x0019E1BC File Offset: 0x0019C3BC
private void RenderSourceToMask(LOSSource losSource, int num, Vector3 center)
{
Camera camera = losSource.SourceCamera;
if (!camera)
{
camera = losSource.gameObject.GetComponent<Camera>();
losSource.SetCamera(camera);
}
int num2 = this.currentLightIndex * 6;
if (num + num2 < this.savedTextures.Count)
{
Materials.SkyBox.SetVector(ShaderID.FarPlane, new Vector4(camera.farClipPlane, camera.farClipPlane, camera.farClipPlane, camera.farClipPlane));
camera.targetTexture = this.savedTextures[num + num2];
FieldInfo field = typeof(Canvas).GetField("willRenderCanvases", BindingFlags.Static | BindingFlags.NonPublic);
object value = field.GetValue(null);
field.SetValue(null, null);
camera.RenderWithShader(Shaders.Depth, null);
field.SetValue(null, value);
this.sourcePositions[num + num2] = losSource.gameObject.transform.position + losSource.gameObject.transform.forward;
this.projectionMatrix[num + num2] = camera.projectionMatrix * camera.worldToCameraMatrix;
}
}
// Token: 0x06001663 RID: 5731 RVA: 0x0019E2D4 File Offset: 0x0019C4D4
public bool TestPlanesAABBInternalFastBounds(Vector3 boundsMin, Vector3 boundsMax)
{
for (int i = 0; i < this.planes.Length; i++)
{
Vector3 normal = this.planes[i].normal;
float distance = this.planes[i].distance;
Vector3 vector;
Vector3 vector2;
if (normal.x < 0f)
{
vector.x = boundsMin.x;
vector2.x = boundsMax.x;
}
else
{
vector.x = boundsMax.x;
vector2.x = boundsMin.x;
}
if (normal.y < 0f)
{
vector.y = boundsMin.y;
vector2.y = boundsMax.y;
}
else
{
vector.y = boundsMax.y;
vector2.y = boundsMin.y;
}
if (normal.z < 0f)
{
vector.z = boundsMin.z;
vector2.z = boundsMax.z;
}
else
{
vector.z = boundsMax.z;
vector2.z = boundsMin.z;
}
if (normal.x * vector.x + normal.y * vector.y + normal.z * vector.z + distance < 0f)
{
return false;
}
}
return true;
}
// Token: 0x0400264A RID: 9802
public int texSize = 512;
// Token: 0x0400264B RID: 9803
private static Plane[] m_CameraFrustumPlanes = new Plane[6];
// Token: 0x0400264C RID: 9804
public List<LOSSource> casters = new List<LOSSource>();
// Token: 0x0400264D RID: 9805
private Camera m_Camera;
// Token: 0x0400264E RID: 9806
public List<float> cameraDistance = new List<float>();
// Token: 0x0400264F RID: 9807
public List<Vector3> cameraPosition = new List<Vector3>();
// Token: 0x04002650 RID: 9808
public List<Matrix4x4> projectionMatrix = new List<Matrix4x4>();
// Token: 0x04002651 RID: 9809
public List<RenderTexture> savedTextures = new List<RenderTexture>();
// Token: 0x04002652 RID: 9810
public List<Vector3> sourcePositions = new List<Vector3>();
// Token: 0x04002653 RID: 9811
private CommandBuffer buffer;
// Token: 0x04002654 RID: 9812
public GameObject pointLightObject;
// Token: 0x04002655 RID: 9813
public Light currentLight;
// Token: 0x04002656 RID: 9814
private int width;
// Token: 0x04002657 RID: 9815
private int height;
// Token: 0x04002658 RID: 9816
private int quadW;
// Token: 0x04002659 RID: 9817
private int quadH;
// Token: 0x0400265A RID: 9818
public RenderTexture combinedLights;
// Token: 0x0400265B RID: 9819
public RenderTexture combinedLights2;
// Token: 0x0400265C RID: 9820
public RenderTexture quadShadowTexture;
// Token: 0x0400265D RID: 9821
public RenderTexture quadShadowTextureFinal;
// Token: 0x0400265E RID: 9822
public Material combineMaterial;
// Token: 0x0400265F RID: 9823
public int currentLightIndex;
// Token: 0x04002660 RID: 9824
public int savedLight1;
// Token: 0x04002661 RID: 9825
public int savedLight2;
// Token: 0x04002662 RID: 9826
public int savedLight3;
// Token: 0x04002663 RID: 9827
public InteriorLights currentInteriorLight;
// Token: 0x04002664 RID: 9828
private List<Light> lights;
// Token: 0x04002665 RID: 9829
public bool baking;
// Token: 0x04002666 RID: 9830
private List<Culling> quads;
// Token: 0x04002667 RID: 9831
public List<MeshRenderer> quadsToRender = new List<MeshRenderer>();
// Token: 0x04002668 RID: 9832
private Plane[] planes = new Plane[0];
// Token: 0x04002669 RID: 9833
public List<Material> quadMats = new List<Material>();
// Token: 0x0400266A RID: 9834
public Shader quadShader;
// Token: 0x0400266B RID: 9835
public bool switchingScenes;
}
}

159
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/ShaderID.cs Normal file
View File

@@ -0,0 +1,159 @@
using System;
using UnityEngine;
namespace LOS
{
// Token: 0x0200010B RID: 267
public class ShaderID
{
// Token: 0x17000037 RID: 55
// (get) Token: 0x0600161C RID: 5660 RVA: 0x0019D42C File Offset: 0x0019B62C
public static int FrustumRays
{
get
{
return Shader.PropertyToID("_FrustumRays");
}
}
// Token: 0x17000038 RID: 56
// (get) Token: 0x0600161D RID: 5661 RVA: 0x0019D438 File Offset: 0x0019B638
public static int FrustumOrigins
{
get
{
return Shader.PropertyToID("_FrustumOrigins");
}
}
// Token: 0x17000039 RID: 57
// (get) Token: 0x0600161E RID: 5662 RVA: 0x0019D444 File Offset: 0x0019B644
public static int WorldToCameraMatrix
{
get
{
return Shader.PropertyToID("_WorldToCameraMatrix");
}
}
// Token: 0x1700003A RID: 58
// (get) Token: 0x0600161F RID: 5663 RVA: 0x0019D450 File Offset: 0x0019B650
public static int SourceDepthTex
{
get
{
return Shader.PropertyToID("_SourceDepthTex");
}
}
// Token: 0x1700003B RID: 59
// (get) Token: 0x06001620 RID: 5664 RVA: 0x0019D45C File Offset: 0x0019B65C
public static int SourceDepthCube
{
get
{
return Shader.PropertyToID("_SourceDepthCube");
}
}
// Token: 0x1700003C RID: 60
// (get) Token: 0x06001621 RID: 5665 RVA: 0x0019D468 File Offset: 0x0019B668
public static int SourceWorldProj
{
get
{
return Shader.PropertyToID("_SourceWorldProj");
}
}
// Token: 0x1700003D RID: 61
// (get) Token: 0x06001622 RID: 5666 RVA: 0x0019D474 File Offset: 0x0019B674
public static int SourceInfo
{
get
{
return Shader.PropertyToID("_SourceInfo");
}
}
// Token: 0x1700003E RID: 62
// (get) Token: 0x06001623 RID: 5667 RVA: 0x0019D480 File Offset: 0x0019B680
public static int Settings
{
get
{
return Shader.PropertyToID("_Settings");
}
}
// Token: 0x1700003F RID: 63
// (get) Token: 0x06001624 RID: 5668 RVA: 0x0019D48C File Offset: 0x0019B68C
public static int Flags
{
get
{
return Shader.PropertyToID("_Flags");
}
}
// Token: 0x17000040 RID: 64
// (get) Token: 0x06001625 RID: 5669 RVA: 0x0019D498 File Offset: 0x0019B698
public static int ColorMask
{
get
{
return Shader.PropertyToID("_ColorMask");
}
}
// Token: 0x17000041 RID: 65
// (get) Token: 0x06001626 RID: 5670 RVA: 0x0019D4A4 File Offset: 0x0019B6A4
public static int FarPlane
{
get
{
return Shader.PropertyToID("_FarPlane");
}
}
// Token: 0x17000042 RID: 66
// (get) Token: 0x06001627 RID: 5671 RVA: 0x0019D4B0 File Offset: 0x0019B6B0
public static int PreEffectTex
{
get
{
return Shader.PropertyToID("_PreEffectTex");
}
}
// Token: 0x17000043 RID: 67
// (get) Token: 0x06001628 RID: 5672 RVA: 0x0019D4BC File Offset: 0x0019B6BC
public static int MaskTex
{
get
{
return Shader.PropertyToID("_MaskTex");
}
}
// Token: 0x17000044 RID: 68
// (get) Token: 0x06001629 RID: 5673 RVA: 0x0019D4C8 File Offset: 0x0019B6C8
public static int StencilMaskTex
{
get
{
return Shader.PropertyToID("_StencilMask");
}
}
// Token: 0x17000045 RID: 69
// (get) Token: 0x0600162A RID: 5674 RVA: 0x0019D4D4 File Offset: 0x0019B6D4
public static int DebugTex
{
get
{
return Shader.PropertyToID("_DebugTex");
}
}
}
}

71
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/Shaders.cs Normal file
View File

@@ -0,0 +1,71 @@
using System;
using UnityEngine;
namespace LOS
{
// Token: 0x0200010A RID: 266
public class Shaders
{
// Token: 0x17000035 RID: 53
// (get) Token: 0x06001616 RID: 5654 RVA: 0x0019D3A6 File Offset: 0x0019B5A6
public static Shader Depth
{
get
{
if (Shaders.m_Depth == null)
{
Shaders.m_Depth = Shaders.LoadShader("Shaders/LOSDepth");
}
return Shaders.m_Depth;
}
}
// Token: 0x17000036 RID: 54
// (get) Token: 0x06001617 RID: 5655 RVA: 0x0019D3C9 File Offset: 0x0019B5C9
public static Shader DepthCone
{
get
{
if (Shaders.m_DepthCone == null)
{
Shaders.m_DepthCone = Shaders.LoadShader("Shaders/LOSDepthCone");
}
return Shaders.m_DepthCone;
}
}
// Token: 0x06001618 RID: 5656 RVA: 0x0019D3EC File Offset: 0x0019B5EC
public static void DestroyResources()
{
Shaders.m_Depth = null;
Shaders.m_DepthCone = null;
}
// Token: 0x06001619 RID: 5657 RVA: 0x0019D3FA File Offset: 0x0019B5FA
private static Shader LoadShader(string shaderResource)
{
return Resources.Load(shaderResource, typeof(Shader)) as Shader;
}
// Token: 0x0600161A RID: 5658 RVA: 0x0019D411 File Offset: 0x0019B611
public static bool CheckShader(Shader shader)
{
return shader != null && shader.isSupported;
}
// Token: 0x0400262C RID: 9772
private const string DepthShaderPath = "Shaders/LOSDepth";
// Token: 0x0400262D RID: 9773
private const string DepthRGBAShaderPath = "Shaders/LOSDepthRGBA";
// Token: 0x0400262E RID: 9774
private const string DepthShaderPathCone = "Shaders/LOSDepthCone";
// Token: 0x0400262F RID: 9775
private static Shader m_Depth;
// Token: 0x04002630 RID: 9776
private static Shader m_DepthCone;
}
}

20
Projects/BanquetForFools/Source/Assembly-CSharp/LOS/Util.cs Normal file
View File

@@ -0,0 +1,20 @@
using System;
namespace LOS
{
// Token: 0x0200010E RID: 270
public class Util
{
// Token: 0x06001652 RID: 5714 RVA: 0x0019DCA1 File Offset: 0x0019BEA1
public static bool Verify(bool comparison, string message)
{
return comparison;
}
// Token: 0x06001653 RID: 5715 RVA: 0x0019DCA4 File Offset: 0x0019BEA4
public static bool Verify(bool comparison)
{
return comparison;
}
}
}