public void RemoveProjector(ShadowProjector projector)
{
if (!projector.IsLight)
{
if (_ShadowProjectors.Contains(projector))
{
_ShadowProjectors.Remove(projector);
if (_ShadowProjectors.Count == 0)
{
_ProjectorCamera.enabled = false;
}
}
}
else
{
if (_LightProjectors.Contains(projector))
{
_LightProjectors.Remove(projector);
if (_LightProjectors.Count == 0)
{
_ProjectorCameraLight.enabled = false;
}
}
}
}
void Awake()
{
instence = this;
//shadowReplaceShader = Resources.Load<Shader>("Shader/ProjectorShader/ShadowReplace");
//this.GetComponent<Projector>().material = Resources.Load<Material>("Shader/ProjectorShader/ShadowProjector");
//Debug.Log("加载阴影替换ShadowReplace成功！！！！！！！");
}
public static void RefreshShadows()
{
if (ShadowController.IsPreviousRealTimeShadowEnable != GameLevelManager.IsRealTimeShadowOn())
{
XDict <long, EntityParent> allEntities = EntityWorld.Instance.AllEntities;
using (List <EntityParent> .Enumerator enumerator = allEntities.Values.GetEnumerator())
{
while (enumerator.MoveNext())
{
EntityParent current = enumerator.get_Current();
if (current != null & current.Actor)
{
if (ShadowController.IsPreviousRealTimeShadowEnable)
{
ShadowController.SetShadowModelRender(current.Actor.FixTransform, true);
}
else
{
ShadowProjector.ShowShadowProjector(current.Actor.FixTransform, true);
}
ShadowController.ShowShadow(current.ID, current.Actor.FixTransform, false, 0);
}
}
}
}
ShadowController.IsPreviousRealTimeShadowEnable = GameLevelManager.IsRealTimeShadowOn();
}
// Token: 0x060001B4 RID: 436 RVA: 0x0001A380 File Offset: 0x00018580
public void RemoveProjector(ShadowProjector projector)
{
if (this._ShadowProjectors.Contains(projector))
{
this._ShadowProjectors.Remove(projector);
}
}
public void AddProjector(ShadowProjector projector)
{
bool added = false;
if (!projector.IsLight)
{
if (_Tex == null)
{
CreateProjectorEyeTexture(true, false);
}
if (!_ShadowProjectors.Contains(projector))
{
_ShadowProjectors.Add(projector);
added = true;
if (_ProjectorCamera.enabled == false)
{
_ProjectorCamera.enabled = true;
}
}
}
else
{
if (_TexLight == null)
{
CreateProjectorEyeTexture(false, true);
}
if (!_LightProjectors.Contains(projector))
{
_LightProjectors.Add(projector);
added = true;
if (_ProjectorCameraLight.enabled == false)
{
_ProjectorCameraLight.enabled = true;
}
}
}
if (added && projector.GlobalProjectionDir != _GlobalProjectionDir)
{
GlobalProjectionDir = projector.GlobalProjectionDir;
}
if (added && projector.GlobalShadowCullingMode != _GlobalShadowCullingMode)
{
_GlobalShadowCullingMode = projector.GlobalShadowCullingMode;
}
if (added && projector.GlobalShadowResolution != _GlobalShadowResolution)
{
_GlobalShadowResolution = projector.GlobalShadowResolution;
}
}
// Token: 0x060001BB RID: 443 RVA: 0x0001A6D8 File Offset: 0x000188D8
private bool IsProjectionVolumeVisible(Plane[] planes, ShadowProjector projector)
{
float num = 1000000f;
Vector3 center = projector.GetShadowPos() + GlobalProjectorManager.GlobalProjectionDir.normalized * (num * 0.5f);
Vector3 size = new Vector3(Mathf.Abs(GlobalProjectorManager.GlobalProjectionDir.normalized.x), Mathf.Abs(GlobalProjectorManager.GlobalProjectionDir.normalized.y), Mathf.Abs(GlobalProjectorManager.GlobalProjectionDir.normalized.z)) * num;
Bounds bounds = new Bounds(center, size);
float shadowWorldSize = projector.GetShadowWorldSize();
bounds.Encapsulate(new Bounds(projector.GetShadowPos(), new Vector3(shadowWorldSize, shadowWorldSize, shadowWorldSize)));
return(GeometryUtility.TestPlanesAABB(planes, bounds));
}
// Token: 0x060001B3 RID: 435 RVA: 0x0001A334 File Offset: 0x00018534
public void AddProjector(ShadowProjector projector)
{
if (!this._ShadowProjectors.Contains(projector))
{
this._ShadowProjectors.Add(projector);
if (projector.GlobalProjectionDir != this._GlobalProjectionDir)
{
GlobalProjectorManager.GlobalProjectionDir = projector.GlobalProjectionDir;
}
}
}
public static void Open(ShadowProjector shadowProjector)
{
ShadowTextureUVEditor window = (ShadowTextureUVEditor)EditorWindow.GetWindow(typeof(ShadowTextureUVEditor));
#if UNITY_5_1 || UNITY_5_2 || UNITY_5_3 || UNITY_5_4 || UNITY_5_5 || UNITY_5_6 || UNITY_5_7 || UNITY_2017 || UNITY_2018 || UNITY_2019 || UNITY_2020
window.titleContent = new GUIContent("UV Editor");
#else
window.title = "UV Editor";
#endif
window._shadowProjector = shadowProjector;
window._zoomLevel = 1.0f;
window.Show();
}
void ApplyGlobalSettings()
{
ShadowProjector targetShadowProj = (ShadowProjector)target;
Object[] shadowProjectors = GameObject.FindObjectsOfType(typeof(ShadowProjector));
foreach (ShadowProjector shadowProj in shadowProjectors)
{
if (shadowProj.GetInstanceID() != targetShadowProj.GetInstanceID())
{
shadowProj.GlobalProjectionDir = targetShadowProj.GlobalProjectionDir;
shadowProj.GlobalShadowResolution = targetShadowProj.GlobalShadowResolution;
shadowProj.GlobalShadowCullingMode = targetShadowProj.GlobalShadowCullingMode;
shadowProj.GlobalCutOffDistance = targetShadowProj.GlobalCutOffDistance;
shadowProj.GlobalFlipX = targetShadowProj.GlobalFlipX;
shadowProj.GlobalFlipY = targetShadowProj.GlobalFlipY;
EditorUtility.SetDirty(shadowProj);
}
}
}
public void OnEnable()
{
ShadowProjector targetShadowProj = (ShadowProjector)target;
Object[] shadowProjectors = GameObject.FindObjectsOfType(typeof(ShadowProjector));
foreach (ShadowProjector shadowProj in shadowProjectors)
{
if (shadowProj.GetInstanceID() != targetShadowProj.GetInstanceID())
{
targetShadowProj.GlobalProjectionDir = shadowProj.GlobalProjectionDir;
targetShadowProj.GlobalShadowResolution = shadowProj.GlobalShadowResolution;
targetShadowProj.GlobalShadowCullingMode = shadowProj.GlobalShadowCullingMode;
targetShadowProj.GlobalCutOffDistance = shadowProj.GlobalCutOffDistance;
targetShadowProj.GlobalFlipX = shadowProj.GlobalFlipX;
targetShadowProj.GlobalFlipY = shadowProj.GlobalFlipY;
EditorUtility.SetDirty(shadowProj);
break;
}
}
}
public override void OnInspectorGUI()
{
EditorGUILayout.HelpBox(
"The camera needs to be orthographic to work. " +
"Reduce the size, near and far of the camera to improve shadow quality. " +
"Adjust the bias to remove shadow acne", MessageType.Warning);
base.OnInspectorGUI();
if (GUILayout.Button("Bake"))
{
string directory = EditorUtility.SaveFilePanel("Save Shadow Map", Application.dataPath, "shadowmap", "png");
if (!string.IsNullOrEmpty(directory))
{
ShadowProjector projector = (ShadowProjector)target;
string relativePath = "Assets" + directory.Replace(Application.dataPath, "");
Texture2D outputTexture = new Texture2D(_sizeProp.intValue, _sizeProp.intValue, TextureFormat.ARGB32, false);
projector.BakeShadow(outputTexture);
byte[] bytes = outputTexture.EncodeToPNG();
File.WriteAllBytes(directory, bytes);
DestroyImmediate(outputTexture);
TextureImporter importer = AssetImporter.GetAtPath(relativePath) as TextureImporter;
importer.textureFormat = TextureImporterFormat.ARGB32;
importer.mipmapEnabled = false;
AssetDatabase.ImportAsset(relativePath);
AssetDatabase.Refresh();
projector.ShadowMap = AssetDatabase.LoadAssetAtPath(relativePath, typeof(Texture2D)) as Texture2D;
}
}
}
public static Mesh CreatePlane(Vector3 up, Vector3 right, Rect uvRect, Color color, ShadowProjector parent)
{
Mesh planeMesh = new Mesh();
bool shouldFlipX = (GlobalProjectorManager.Exists() ? GlobalProjectorManager.GlobalFlipX : parent.GlobalFlipX);
Vector2 flipX = new Vector2(uvRect.width, -uvRect.width);
bool shouldFlipY = (GlobalProjectorManager.Exists() ? GlobalProjectorManager.GlobalFlipY : parent.GlobalFlipY);
Vector2 flipY = new Vector2(-uvRect.height, uvRect.height);
Vector3[] vertices = new Vector3[] {
(up * 0.5f - right * 0.5f),
(up * 0.5f + right * 0.5f),
(-up * 0.5f - right * 0.5f),
(-up * 0.5f + right * 0.5f)
};
Vector2[] uvs = new Vector2[] {
new Vector2(uvRect.x, uvRect.y + uvRect.height),
new Vector2(uvRect.x + uvRect.width, uvRect.y + uvRect.height),
new Vector2(uvRect.x, uvRect.y),
new Vector2(uvRect.x + uvRect.width, uvRect.y),
};
Color[] colors = new Color[] {
color,
color,
color,
color
};
int[] indices = new int[] { 0, 1, 3, 0, 3, 2 };
if (shouldFlipX)
{
uvs[0].x += flipX[0];
uvs[1].x += flipX[1];
uvs[2].x += flipX[0];
uvs[3].x += flipX[1];
}
if (shouldFlipY)
{
uvs[0].y += flipY[0];
uvs[1].y += flipY[0];
uvs[2].y += flipY[1];
uvs[3].y += flipY[1];
}
planeMesh.vertices = vertices;
planeMesh.uv = uvs;
planeMesh.colors = colors;
planeMesh.SetTriangles(indices, 0);
return(planeMesh);
}
public async override void Start()
{
base.Start();
if (ItemData.renderType == RenderType.Image)
{
gameObject.layer = LayerMask.NameToLayer("CollideWithGround");
bool sdsa = true;
var itemData = ItemManager.Instance.getItemDataById <ItemData>(ItemId);
mainRigidbody.collisionDetectionMode = CollisionDetectionMode.ContinuousDynamic;
if (ItemData.itemType == ItemType.Equip)
{
sdsa = false;
var itemDatad = ItemManager.Instance.getItemDataById <EquipData>(ItemId);
if (itemDatad.imgGround == ImgGround.ground)
{
Texture2D texture = await AssetManager.LoadAssetAsync <Texture2D>(Definition.TextureAssetPrefix + "Icon/" + itemDatad.groundImgId + ".png");
Texture2D texture2d = texture;
float width = texture2d.width / 100f;
float height = texture2d.height / 100f;
MeshFilter meshFilter = gameObject.GetChild("Renderer").GetComponentInChildren <MeshFilter>();
MeshRenderer meshRenderer = gameObject.GetChild("Renderer").GetComponentInChildren <MeshRenderer>();
Material blackMaterial;
// 初始化mesh uv 等add by TangJian 2017/12/20 17:04:45
{
// Shader shader = Shader.Find("Custom/Unlit/Transparent");
// Shader shader = Shader.Find("Spine/W_Sprite");
Shader shader = Shader.Find("Custom/Unlit/Transparent");
{
Mesh mesh = new Mesh();
// 为网格创建顶点数组
Vector3[] vertices = new Vector3[4]
{
new Vector3(width / 2, 0.1f, (height * (float)System.Math.Sqrt(3)) / 2),
new Vector3(-width / 2, 0.1f, (height * (float)System.Math.Sqrt(3)) / 2),
new Vector3(width / 2, 0.1f, (-height * (float)System.Math.Sqrt(3)) / 2),
new Vector3(-width / 2, 0.1f, (-height * (float)System.Math.Sqrt(3)) / 2)
};
// for (int i = 0; i < vertices.Length; i++)
// {
// vertices[i].y += height / 2;
// }
mesh.vertices = vertices;
// 通过顶点为网格创建三角形
int[] triangles = new int[2 * 3] {
0, 3, 1, 0, 2, 3
};
mesh.triangles = triangles;
mesh.uv = new Vector2[] {
new Vector2(1, 1),
new Vector2(0, 1),
new Vector2(1, 0),
new Vector2(0, 0)
};
meshFilter.mesh = mesh;
}
Material material = new Material(shader);
material.mainTexture = texture;
material.renderQueue = 3000;
material.SetFloat("_ZTest", (float)UnityEngine.Rendering.CompareFunction.LessEqual);
material.SetFloat("_ZWrite", 1);
meshRenderer.sortingOrder = 0;
meshRenderer.material = material;
// meshRenderer.material.color=Color.black;
blackMaterial = material;
}
// 根据渲染设置碰撞区域 add by TangJian 2017/11/18 17:32:18
{
BoxCollider boxCollider = gameObject.GetComponent <BoxCollider>();
Bounds bounds = new Bounds(gameObject.transform.position, Vector3.zero);
bounds.Encapsulate(meshRenderer.bounds);
bounds.center = gameObject.transform.InverseTransformPoint(bounds.center);
boxCollider.center = new Vector3(0, 0.5f, 0);;
boxCollider.size = new Vector3(bounds.size.x, 1f, bounds.size.z);
boxCollider.enabled = true;
BoxCollider InteractBoxCollider = gameObject.GetChild("Interact").GetComponent <BoxCollider>();
InteractBoxCollider.center = boxCollider.center;
InteractBoxCollider.size = boxCollider.size + new Vector3(1, 1, 1);
}
float scale = 1.25f;
gameObject.transform.localScale = new Vector3(1, 1, 1) * scale;
// 影子设置 add by TangJian 2017/12/20 15:44:55
// {
// BoxCollider boxCollider = gameObject.GetComponent<BoxCollider>();
GameObject shadow = gameObject.GetChild("Shadow");
shadow.SetActive(false);
// ShadowProjector shadowProjector=shadow.GetComponent<ShadowProjector>();
// shadowProjector._Material=blackMaterial;
// shadowProjector.UVRect=new Rect(0f,0.5f,0.5f,0.5f);
// Bounds blackbound = new Bounds(gameObject.transform.position, Vector3.zero);
// blackbound.Encapsulate(meshRenderer.bounds);
// blackbound.center = gameObject.transform.InverseTransformPoint(blackbound.center);
// shadowProjector.UVRect=new Rect(0f,0.5f,0.5f,0.5f);
// shadowProjector.AutoSizeOpacity=true;
// shadowProjector.AutoSOMaxScaleMultiplier=0.5f;
// shadowProjector.ShadowSize = blackbound.size.x;
// ShadowProjector shadowProjector = shadow.GetComponent<ShadowProjector>();
// shadow.transform.localPosition = new Vector3(0, 0, 0);
// Projector Projector=shadow.GetComponent<Projector>();
// blackMaterial.color=Color.black;
// Projector.material=blackMaterial;
// shadowController.shadowSize = boxCollider.size.x * gameObject.transform.localScale.x;
// shadowController.shadowSize *= 0.6f;
// }
}
else
{
sdsa = true;
}
}
if (itemData.icon.IsValid() && sdsa)
{
Texture2D texture = await AssetManager.LoadAssetAsync <Texture2D>(Definition.TextureAssetPrefix + "Icon/" + itemData.icon + ".png");
float width = texture.width / 100f;
float height = texture.height / 100f;
MeshFilter meshFilter = gameObject.GetChild("Renderer", true).GetComponentInChildren <MeshFilter>();
MeshRenderer meshRenderer = gameObject.GetChild("Renderer", true).GetComponentInChildren <MeshRenderer>();
gameObject.GetChild("Renderer").AddComponent <SortRenderer>();
// 初始化mesh uv 等add by TangJian 2017/12/20 17:04:45
{
// Shader shader = Shader.Find("Custom/Unlit/Transparent");
// Shader shader = Shader.Find("Spine/W_Sprite");
Shader shader = Shader.Find("Custom/Unlit/Transparent");
{
Mesh mesh = new Mesh();
// 为网格创建顶点数组
Vector3[] vertices = new Vector3[4] {
new Vector3(width / 2, height / 2, 0),
new Vector3(-width / 2, height / 2, 0),
new Vector3(width / 2, -height / 2, 0),
new Vector3(-width / 2, -height / 2, 0)
};
for (int i = 0; i < vertices.Length; i++)
{
vertices[i].y += height / 2;
}
mesh.vertices = vertices;
// 通过顶点为网格创建三角形
int[] triangles = new int[2 * 3] {
0, 3, 1, 0, 2, 3
};
mesh.triangles = triangles;
mesh.uv = new Vector2[] {
new Vector2(1, 1),
new Vector2(0, 1),
new Vector2(1, 0),
new Vector2(0, 0)
};
meshFilter.mesh = mesh;
}
Material material = new Material(shader);
material.mainTexture = texture;
material.renderQueue = 3000;
material.SetFloat("_Cutoff", 0.2f);
material.SetFloat("_ZTest", (float)UnityEngine.Rendering.CompareFunction.LessEqual);
material.SetFloat("_ZWrite", 1);
//material.SetFloat("_ZTest", 1);
meshRenderer.material = material;
}
// 根据渲染设置碰撞区域 add by TangJian 2017/11/18 17:32:18
{
BoxCollider boxCollider = gameObject.GetComponent <BoxCollider>();
Bounds bounds = new Bounds(gameObject.transform.position, Vector3.zero);
bounds.Encapsulate(meshRenderer.bounds);
bounds.center = gameObject.transform.InverseTransformPoint(bounds.center);
boxCollider.center = bounds.center;
boxCollider.size = bounds.size;
BoxCollider InteractBoxCollider = gameObject.GetChild("Interact").GetComponent <BoxCollider>();
InteractBoxCollider.center = boxCollider.center;
InteractBoxCollider.size = boxCollider.size + new Vector3(1, 1, 1);
}
float scale = 1.25f;
gameObject.transform.localScale = new Vector3(1, 1, 1) * scale;
// 影子设置 add by TangJian 2017/12/20 15:44:55
{
// BoxCollider boxCollider = gameObject.GetComponent<BoxCollider>();
GameObject shadow = gameObject.GetChild("Shadow");
ShadowProjector shadowProjector = shadow.GetComponent <ShadowProjector>();
// shadowProjector.UVRect=new Rect(0f,0.5f,0.5f,0.5f);
// shadowProjector.UVRect=new Rect(0f,0.5f,0.5f,0.5f);
// Material material=(Material)UnityEditor.AssetDatabase.LoadAssetAtPath("Assets/Standard Assets/Effects/Projectors/Materials/ShadowProjector.mat",typeof(Material));
// shadowProjector._Material=material;
// shadowProjector.AutoSizeOpacity=true;
// shadowProjector.AutoSOMaxScaleMultiplier=0.5f;
shadowProjector.ShadowSize = width * 0.6f;
// shadowProjector.AutoSizeOpacity=true;
// shadowProjector.AutoSOMaxScaleMultiplier=0.5f;
// ShadowController shadowController = shadow.GetComponent<ShadowController>();
// shadow.transform.localPosition = new Vector3(0, 0, 0);
// shadowController.shadowSize = boxCollider.size.x * gameObject.transform.localScale.x;
// shadowController.shadowSize *= 0.6f;
}
}
if (animSequence == null && sdsa)
{
animSequence = DOTween.Sequence();
// 播放动画 add by TangJian 2017/12/25 15:43:55
animSequence.Append(gameObject.GetChild("Renderer").transform.DOLocalMoveY(0.2f, 2f));
animSequence.Append(gameObject.GetChild("Renderer").transform.DOLocalMoveY(0f, 2f)).OnComplete(() =>
{
animSequence.Restart();
});
}
}
else if (ItemData.renderType == RenderType.Anim)
{
GameObject animObject = gameObject.GetChild("Renderer").GetChild("anim", true);
_skeletonAnimation = animObject.AddComponentIfNone <SkeletonAnimation>();
_skeletonAnimation.skeletonDataAsset = await AssetManager.LoadAssetAsync <SkeletonDataAsset>(ItemData.anim);
_skeletonAnimation.Initialize(true);
_skeletonAnimation.state.SetAnimation(0, itemData.idleAnim, true);
// _functionPool.AddFunc(() =>
// {
// if (_skeletonAnimation != null && _skeletonAnimation.state != null)
// {
// _skeletonAnimation.state.SetAnimation(0, itemData.idleAnim, true);
// return true;
// }
//
// return false;
// });
}
InitPickUpMethod();
}
// Token: 0x060001BA RID: 442 RVA: 0x0001A460 File Offset: 0x00018660
private void CalculateShadowBounds()
{
Plane[] planes = GeometryUtility.CalculateFrustumPlanes(Camera.main);
Vector2 vector = new Vector2(float.MaxValue, float.MinValue);
Vector2 vector2 = new Vector2(float.MaxValue, float.MinValue);
float num = 10f;
bool flag = true;
int num2 = 0;
int num3 = 0;
Bounds bounds = default(Bounds);
int i = 0;
while (i < this._ShadowProjectors.Count)
{
ShadowProjector shadowProjector = this._ShadowProjectors[i];
GlobalProjectorManager.ProjectionCulling globalShadowCullingMode = this._GlobalShadowCullingMode;
if (globalShadowCullingMode != GlobalProjectorManager.ProjectionCulling.ProjectorBounds)
{
if (globalShadowCullingMode != GlobalProjectorManager.ProjectionCulling.ProjectionVolumeBounds)
{
goto IL_D1;
}
if (this.IsProjectionVolumeVisible(planes, shadowProjector))
{
goto IL_D1;
}
num3++;
shadowProjector.SetVisible(false);
}
else
{
if (GeometryUtility.TestPlanesAABB(planes, shadowProjector.GetBounds()))
{
goto IL_D1;
}
num3++;
shadowProjector.SetVisible(false);
}
IL_1C1:
i++;
continue;
IL_D1:
flag = false;
shadowProjector.SetVisible(true);
Vector2 vector3 = base.camera.WorldToViewportPoint(shadowProjector.GetShadowPos());
if (num2 == 0)
{
bounds = new Bounds(shadowProjector.GetShadowPos(), Vector3.zero);
}
else
{
bounds.Encapsulate(shadowProjector.GetShadowPos());
}
if (vector3.x < vector.x)
{
vector.x = vector3.x;
}
if (vector3.x > vector.y)
{
vector.y = vector3.x;
}
if (vector3.y < vector2.x)
{
vector2.x = vector3.y;
}
if (vector3.y > vector2.y)
{
vector2.y = vector3.y;
}
float shadowWorldSize = shadowProjector.GetShadowWorldSize();
if (shadowWorldSize > num)
{
num = shadowWorldSize;
}
num2++;
goto IL_1C1;
}
if (flag)
{
return;
}
float num4 = base.camera.orthographicSize * 2f;
float num5 = num / num4;
Vector3 center = bounds.center;
base.camera.transform.position = center;
float num6 = Mathf.Max(vector[1] - vector[0] + num5 * 2f, vector2[1] - vector2[0] + num5 * 2f);
base.camera.orthographicSize = base.camera.orthographicSize * num6;
}
public override void OnInspectorGUI()
{
serializedObject.Update();
ShadowProjector shadowProj = (ShadowProjector)target;
shadowProj.GlobalProjectionDir = EditorGUILayout.Vector3Field("Global light direction", shadowProj.GlobalProjectionDir, null);
shadowProj.GlobalShadowResolution = EditorGUILayout.Popup("Global shadow resolution", shadowProj.GlobalShadowResolution, _ShadowResOptions);
shadowProj.GlobalShadowCullingMode = (GlobalProjectorManager.ProjectionCulling)EditorGUILayout.Popup("Global culling mode", (int)shadowProj.GlobalShadowCullingMode, _CullingOptions);
shadowProj.EnableCutOff = EditorGUILayout.BeginToggleGroup("Cutoff shadow by distance?", shadowProj.EnableCutOff);
shadowProj.GlobalCutOffDistance = EditorGUILayout.Slider("Global cutoff distance", shadowProj.GlobalCutOffDistance, 1.0f, 10000.0f);
EditorGUILayout.EndToggleGroup();
shadowProj.GlobalFlipX = EditorGUILayout.Toggle("Global flip shadows X:", shadowProj.GlobalFlipX);
shadowProj.GlobalFlipY = EditorGUILayout.Toggle("Global flip shadows Y:", shadowProj.GlobalFlipY);
shadowProj.ShadowSize = EditorGUILayout.FloatField("Shadow size", shadowProj.ShadowSize);
shadowProj.ShadowColor = EditorGUILayout.ColorField("Shadow color", shadowProj.ShadowColor);
shadowProj.ShadowOpacity = EditorGUILayout.Slider("Shadow opacity", shadowProj.ShadowOpacity, 0.0f, 1.0f);
shadowProj.IsLight = EditorGUILayout.Toggle("Is light?", shadowProj.IsLight);
shadowProj._Material = (Material)EditorGUILayout.ObjectField("Shadow material", (Object)shadowProj._Material, typeof(Material), false, null);
EditorGUILayout.LabelField("Shadow UV Rect");
UVRect = shadowProj.UVRect;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("X:", GUILayout.MaxWidth(15));
UVRect.x = EditorGUILayout.FloatField(UVRect.x, GUILayout.ExpandWidth(true));
EditorGUILayout.LabelField("Y:", GUILayout.MaxWidth(15));
UVRect.y = EditorGUILayout.FloatField(UVRect.y, GUILayout.ExpandWidth(true));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("W:", GUILayout.MaxWidth(15));
UVRect.width = EditorGUILayout.FloatField(UVRect.width, GUILayout.ExpandWidth(true));
EditorGUILayout.LabelField("H:", GUILayout.MaxWidth(15));
UVRect.height = EditorGUILayout.FloatField(UVRect.height, GUILayout.ExpandWidth(true));
EditorGUILayout.EndHorizontal();
shadowProj.ShadowLocalOffset = EditorGUILayout.Vector3Field("Shadow local offset", shadowProj.ShadowLocalOffset, null);
shadowProj.RotationAngleOffset = Quaternion.Euler(EditorGUILayout.Vector3Field("Rotation angle offsets", shadowProj.RotationAngleOffset.eulerAngles));
EditorGUILayout.LabelField("Freeze rotation:");
shadowProj.FreezeXRot = EditorGUILayout.Toggle(" X", shadowProj.FreezeXRot);
shadowProj.FreezeYRot = EditorGUILayout.Toggle(" Y", shadowProj.FreezeYRot);
shadowProj.FreezeZRot = EditorGUILayout.Toggle(" Z", shadowProj.FreezeZRot);
if (GUILayout.Button("Open UV Editor"))
{
ShadowTextureUVEditor.Open(shadowProj);
}
shadowProj.AutoSizeOpacity = EditorGUILayout.BeginToggleGroup("Auto opacity/size:", shadowProj.AutoSizeOpacity);
shadowProj.AutoSORaycastLayer = EditorGUILayout.LayerField("Raycast layer", shadowProj.AutoSORaycastLayer);
shadowProj.AutoSORayOriginOffset = EditorGUILayout.FloatField("Ray origin offset", shadowProj.AutoSORayOriginOffset);
shadowProj.AutoSOCutOffDistance = EditorGUILayout.FloatField("Cutoff distance", shadowProj.AutoSOCutOffDistance);
shadowProj.AutoSOMaxScaleMultiplier = EditorGUILayout.FloatField("Max scale multiplier", shadowProj.AutoSOMaxScaleMultiplier);
EditorGUILayout.EndToggleGroup();
shadowProj.UVRect = UVRect;
if (!GlobalProjectorLayerExists())
{
CheckGlobalProjectorLayer();
}
serializedObject.ApplyModifiedProperties();
ApplyGlobalSettings();
if (GUI.changed)
{
EditorUtility.SetDirty(target);
}
}
