private void OnEnable()
{
dayLightCollider2D = target as DayLightCollider2D;
InitProperties();
Undo.undoRedoPerformed += RefreshAll;
}
static public void Draw(DayLightCollider2D id, Vector2 position)
{
if (id.mainShape.shadowType == DayLightCollider2D.ShadowType.None)
{
return;
}
if (id.mainShape.shadowType == DayLightCollider2D.ShadowType.SpriteOffset)
{
return;
}
if (id.mainShape.shadowType == DayLightCollider2D.ShadowType.SpriteProjection)
{
return;
}
if (id.mainShape.height < 0)
{
return;
}
if (id.InAnyCamera() == false)
{
return;
}
Color color = new Color(id.shadowTranslucency, id.shadowTranslucency, id.shadowTranslucency, 1);
GL.Color(color);
foreach (DayLightColliderShape shape in id.shapes)
{
DayLighting.ShadowMesh shadow = shape.shadowMesh;
if (shadow == null)
{
continue;
}
Vector3 pos = new Vector3(shape.transform2D.position.x + position.x, shape.transform2D.position.y + position.y, 0);
Matrix4x4 matrix = Matrix4x4.TRS(pos, Quaternion.Euler(0, 0, 0), Vector3.one);
foreach (MeshObject mesh in shadow.softMeshes)
{
GLExtended.DrawMeshPass(mesh, pos, Vector3.one, 0);
}
foreach (MeshObject mesh in shadow.meshes)
{
GLExtended.DrawMeshPass(mesh, pos, Vector3.one, 0);
}
}
}
static public void Draw(DayLightCollider2D id, Vector2 offset)
{
if (id.mainShape.shadowType != DayLightCollider2D.ShadowType.SpriteOffset)
{
return;
}
if (id.InAnyCamera() == false)
{
return;
}
Material material = Lighting2D.materials.GetSpriteShadow();
material.color = Color.black;
foreach (DayLightColliderShape shape in id.shapes)
{
SpriteRenderer spriteRenderer = shape.spriteShape.GetSpriteRenderer();
if (spriteRenderer == null)
{
continue;
}
virtualSpriteRenderer.sprite = spriteRenderer.sprite;
virtualSpriteRenderer.flipX = spriteRenderer.flipX;
virtualSpriteRenderer.flipY = spriteRenderer.flipY;
if (virtualSpriteRenderer.sprite == null)
{
continue;
}
float x = id.transform.position.x + offset.x;
float y = id.transform.position.y + offset.y;
float rot = -Lighting2D.DayLightingSettings.direction * Mathf.Deg2Rad;
float sunHeight = Lighting2D.DayLightingSettings.height;
x += Mathf.Cos(rot) * id.mainShape.height * sunHeight;
y += Mathf.Sin(rot) * id.mainShape.height * sunHeight;
material.mainTexture = virtualSpriteRenderer.sprite.texture;
Vector2 scale = new Vector2(id.transform.lossyScale.x, id.transform.lossyScale.y);
Universal.Sprite.FullRect.Simple.Draw(id.spriteMeshObject, material, virtualSpriteRenderer, new Vector2(x, y), scale, id.transform.rotation.eulerAngles.z);
}
material.color = Color.white;
}
static void CreateDayLightCollider()
{
GameObject newGameObject = new GameObject("DayLight Collider 2D");
newGameObject.AddComponent <PolygonCollider2D>();
DayLightCollider2D c = newGameObject.AddComponent <DayLightCollider2D>();
c.mainShape.shadowType = DayLightCollider2D.ShadowType.Collider;
c.mainShape.maskType = DayLightCollider2D.MaskType.None;
newGameObject.transform.position = GetCameraPoint();
}
private static void DrawColliderShadows(Pass pass)
{
for (int i = 0; i < pass.colliderCount; i++)
{
DayLightCollider2D id = pass.colliderList[i];
if (id.shadowLayer != pass.layerId)
{
continue;
}
Shadow.Draw(id, pass.offset);
}
}
private static void DrawColliderMasks(Pass pass)
{
for (int i = 0; i < pass.colliderCount; i++)
{
DayLightCollider2D id = pass.colliderList[i];
if (id.maskLayer != pass.layerId)
{
continue;
}
SpriteRenderer2D.Draw(id, pass.offset);
}
}
static public void Draw(DayLightCollider2D id, Vector2 offset)
{
if (id.InAnyCamera() == false)
{
return;
}
float dayLightRotation = -(Lighting2D.DayLightingSettings.direction - 180) * Mathf.Deg2Rad;
float dayLightHeight = Lighting2D.DayLightingSettings.bumpMap.height;
float dayLightStrength = Lighting2D.DayLightingSettings.bumpMap.strength;
switch (id.mainShape.maskType)
{
case DayLightCollider2D.MaskType.None:
return;
case DayLightCollider2D.MaskType.Sprite:
Material material = Lighting2D.materials.GetMask();
foreach (DayLightColliderShape shape in id.shapes)
{
UnityEngine.SpriteRenderer spriteRenderer = shape.spriteShape.GetSpriteRenderer();
if (spriteRenderer == null || spriteRenderer.sprite == null)
{
continue;
}
Vector2 objectOffset = shape.transform2D.position + offset;
material.mainTexture = spriteRenderer.sprite.texture;
Universal.Sprite.Draw(id.spriteMeshObject, material, spriteRenderer, objectOffset, shape.transform2D.scale, shape.transform2D.rotation);
}
break;
case DayLightCollider2D.MaskType.BumpedSprite:
Texture bumpTexture = id.normalMapMode.GetBumpTexture();
if (bumpTexture == null)
{
return;
}
material = Lighting2D.materials.GetBumpedDaySprite();
material.SetFloat("_LightRZ", -dayLightHeight);
material.SetTexture("_Bump", bumpTexture);
foreach (DayLightColliderShape shape in id.shapes)
{
UnityEngine.SpriteRenderer spriteRenderer = shape.spriteShape.GetSpriteRenderer();
if (spriteRenderer == null || spriteRenderer.sprite == null)
{
continue;
}
float rotation = dayLightRotation - shape.transform2D.rotation * Mathf.Deg2Rad;
material.SetFloat("_LightRX", Mathf.Cos(rotation) * dayLightStrength);
material.SetFloat("_LightRY", Mathf.Sin(rotation) * dayLightStrength);
Vector2 objectOffset = shape.transform2D.position + offset;
material.mainTexture = spriteRenderer.sprite.texture;
Universal.Sprite.FullRect.Draw(id.spriteMeshObject, material, spriteRenderer, objectOffset, id.transform.lossyScale, shape.transform2D.rotation);
}
break;
}
}
static public void Draw(Pass pass)
{
for (int id = 0; id < pass.sortList.count; id++)
{
Sorting.SortObject sortObject = pass.sortList.list[id];
switch (sortObject.type)
{
case Sorting.SortObject.Type.Collider:
DayLightCollider2D collider = (DayLightCollider2D)sortObject.lightObject;
if (collider != null)
{
if (collider.InAnyCamera() == false)
{
continue;
}
if (pass.drawShadows)
{
if (collider.mainShape.shadowType == DayLightCollider2D.ShadowType.Collider || collider.mainShape.shadowType == DayLightCollider2D.ShadowType.SpritePhysicsShape)
{
Lighting2D.materials.GetShadowBlur().SetPass(0);
GL.Begin(GL.TRIANGLES);
Shadow.Draw(collider, pass.offset);
GL.End();
}
SpriteRendererShadow.Draw(collider, pass.offset);
}
if (pass.drawMask)
{
SpriteRenderer2D.Draw(collider, pass.offset);
}
}
break;
case Sorting.SortObject.Type.TilemapCollider:
DayLightTilemapCollider2D tilemap = (DayLightTilemapCollider2D)sortObject.lightObject;
if (tilemap != null)
{
if (pass.drawShadows)
{
if (tilemap.ShadowsDisabled() == false)
{
Lighting2D.materials.GetShadowBlur().SetPass(0);
GL.Begin(GL.TRIANGLES);
Shadow.DrawTilemap(tilemap, pass.offset);
GL.End();
}
}
if (pass.drawMask)
{
if (tilemap.MasksDisabled() == false)
{
SpriteRenderer2D.DrawTilemap(tilemap, pass.offset);
}
}
}
break;
}
}
}
override public void OnInspectorGUI()
{
DayLightCollider2D script = target as DayLightCollider2D;
// Shadow Properties
EditorGUILayout.PropertyField(shadowType, new GUIContent("Shadow Type"));
EditorGUI.BeginDisabledGroup(script.mainShape.shadowType == DayLightCollider2D.ShadowType.None);
shadowLayer.intValue = EditorGUILayout.Popup("Shadow Layer (Day)", shadowLayer.intValue, Lighting2D.Profile.layers.dayLayers.GetNames());
EditorGUILayout.PropertyField(shadowDistance, new GUIContent("Shadow Distance"));
if (script.mainShape.shadowType == DayLightCollider2D.ShadowType.SpriteProjection)
{
EditorGUILayout.PropertyField(shadowThickness, new GUIContent("Shadow Thickness"));
}
EditorGUILayout.PropertyField(shadowTranslucency, new GUIContent("Shadow Translucency"));
EditorGUI.EndDisabledGroup();
EditorGUILayout.Space();
// Mask Properties
EditorGUILayout.PropertyField(maskType, new GUIContent("Mask Type"));
EditorGUI.BeginDisabledGroup(script.mainShape.maskType == DayLightCollider2D.MaskType.None);
maskLayer.intValue = EditorGUILayout.Popup("Mask Layer (Day)", maskLayer.intValue, Lighting2D.Profile.layers.dayLayers.GetNames());
if (script.mainShape.maskType == DayLightCollider2D.MaskType.BumpedSprite)
{
GUIBumpMapMode.DrawDay(script.normalMapMode);
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.Space();
// Other Properties
EditorGUILayout.PropertyField(applyToChildren, new GUIContent("Apply To Children"));
EditorGUILayout.Space();
serializedObject.ApplyModifiedProperties();
if (GUILayout.Button("Update"))
{
SpriteExtension.PhysicsShapeManager.Clear();
foreach (Object target in targets)
{
DayLightCollider2D daylightCollider2D = target as DayLightCollider2D;
daylightCollider2D.mainShape.ResetLocal();
daylightCollider2D.Initialize();
}
}
if (GUI.changed)
{
foreach (Object target in targets)
{
DayLightCollider2D daylightCollider2D = target as DayLightCollider2D;
daylightCollider2D.Initialize();
if (EditorApplication.isPlaying == false)
{
EditorUtility.SetDirty(target);
}
}
if (EditorApplication.isPlaying == false)
{
EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
}
}
}
void RefreshAll()
{
DayLightCollider2D.ForceUpdateAll();
}
public void SortObjects()
{
sortList.Reset();
List <DayLightCollider2D> colliderList = DayLightCollider2D.List;
for (int id = 0; id < colliderList.Count; id++)
{
DayLightCollider2D collider = colliderList[id];
if (collider.shadowLayer != layerId && collider.maskLayer != layerId)
{
continue;
}
switch (layer.sorting)
{
case LayerSorting.ZAxisLower:
sortList.Add((object)collider, Sorting.SortObject.Type.Collider, -collider.transform.position.z);
break;
case LayerSorting.ZAxisHigher:
sortList.Add((object)collider, Sorting.SortObject.Type.Collider, collider.transform.position.z);
break;
}
switch (layer.sorting)
{
case LayerSorting.YAxisLower:
sortList.Add((object)collider, Sorting.SortObject.Type.Collider, -collider.transform.position.y);
break;
case LayerSorting.YAxisHigher:
sortList.Add((object)collider, Sorting.SortObject.Type.Collider, collider.transform.position.y);
break;
}
}
List <DayLightTilemapCollider2D> tilemapColliderList = DayLightTilemapCollider2D.list;
for (int id = 0; id < tilemapColliderList.Count; id++)
{
DayLightTilemapCollider2D tilemap = tilemapColliderList[id];
if (tilemap.shadowLayer != layerId && tilemap.maskLayer != layerId)
{
continue;
}
switch (layer.sorting)
{
case LayerSorting.ZAxisLower:
sortList.Add((object)tilemap, Sorting.SortObject.Type.TilemapCollider, -tilemap.transform.position.z);
break;
case LayerSorting.ZAxisHigher:
sortList.Add((object)tilemap, Sorting.SortObject.Type.TilemapCollider, tilemap.transform.position.z);
break;
}
switch (layer.sorting)
{
case LayerSorting.YAxisLower:
sortList.Add((object)tilemap, Sorting.SortObject.Type.TilemapCollider, -tilemap.transform.position.y);
break;
case LayerSorting.YAxisHigher:
sortList.Add((object)tilemap, Sorting.SortObject.Type.TilemapCollider, tilemap.transform.position.y);
break;
}
}
sortList.Sort();
}
static public void DrawProjection(DayLightCollider2D id, Vector2 offset)
{
if (id.mainShape.shadowType != DayLightCollider2D.ShadowType.SpriteProjection)
{
return;
}
if (id.InAnyCamera() == false)
{
return;
}
Material material = Lighting2D.materials.GetSpriteShadow();
material.color = Color.black;
foreach (DayLightColliderShape shape in id.shapes)
{
SpriteRenderer spriteRenderer = shape.spriteShape.GetSpriteRenderer();
if (spriteRenderer == null)
{
continue;
}
virtualSpriteRenderer.sprite = spriteRenderer.sprite;
virtualSpriteRenderer.flipX = spriteRenderer.flipX;
virtualSpriteRenderer.flipY = spriteRenderer.flipY;
Sprite sprite = virtualSpriteRenderer.sprite;
if (virtualSpriteRenderer.sprite == null)
{
continue;
}
float sunHeight = Lighting2D.DayLightingSettings.height;
float rot = Lighting2D.DayLightingSettings.direction * Mathf.Deg2Rad;
Vector2 pos = new Vector2(id.transform.position.x + offset.x, id.transform.position.y + offset.y);
Vector2 scale = new Vector2(id.transform.lossyScale.x, id.transform.lossyScale.y);
SpriteTransform spriteTransform = new SpriteTransform(virtualSpriteRenderer, pos, scale, id.transform.rotation.eulerAngles.z);
Rect uv = spriteTransform.uv;
float pivotY = (float)sprite.pivot.y / sprite.texture.height;
pivotY = uv.y + pivotY;
float pivotX = (float)sprite.pivot.x / sprite.texture.width;
Pair2 pair = Pair2.Zero();
pair.A = pos + pair.A.Push(-rot + Mathf.PI / 2, id.shadowThickness);
pair.B = pos + pair.B.Push(-rot - Mathf.PI / 2, id.shadowThickness);
if (Lighting2D.DayLightingSettings.direction < 180)
{
float uvx = uv.x;
uv.x = uv.width;
uv.width = uvx;
}
Vector2 v1 = pair.A;
Vector2 v2 = pair.A;
Vector2 v3 = pair.B;
Vector2 v4 = pair.B;
v2 = v2.Push(-rot, id.shadowDistance * sunHeight);
v3 = v3.Push(-rot, id.shadowDistance * sunHeight);
material.mainTexture = virtualSpriteRenderer.sprite.texture;
material.SetPass(0);
GL.Begin(GL.QUADS);
GL.Color(GLExtended.color);
GL.TexCoord3(uv.x, pivotY, 0);
GL.Vertex3(v1.x, v1.y, 0);
GL.TexCoord3(uv.x, uv.height, 0);
GL.Vertex3(v2.x, v2.y, 0);
GL.TexCoord3(uv.width, uv.height, 0);
GL.Vertex3(v3.x, v3.y, 0);
GL.TexCoord3(uv.width, pivotY, 0);
GL.Vertex3(v4.x, v4.y, 0);
GL.End();
}
material.color = Color.white;
}
