// Post-Render Mode Drawing
public static void PostRender(LightingMainBuffer2D mainBuffer)
{
Camera camera = mainBuffer.cameraSettings.GetCamera();
if (camera == null)
{
return;
}
if (mainBuffer.cameraSettings.renderMode == CameraSettings.RenderMode.Disabled)
{
return;
}
if (Lighting2D.RenderingMode != RenderingMode.OnPostRender)
{
return;
}
if (Camera.current != camera)
{
return;
}
Rendering.Universal.Texture.Draw(mainBuffer.GetMaterial(), LightingPosition.GetCameraPlanePosition(camera), GetSize(camera), camera.transform.eulerAngles.z, LightingPosition.GetCameraPlanePosition(camera).z);
}
static public void DrawCircle(Vector3 position, float rotation, float angle, float size)
{
Vector3 center = position;
int step = 10;
int start = -(int)(angle / 2);
int end = (int)(angle / 2);
for (int i = start; i < end; i += step)
{
float rot = i + 90 + rotation;
float rotA = rot * Mathf.Deg2Rad;
float rotB = (rot + step) * Mathf.Deg2Rad;
Vector3 pointA = LightingPosition.GetPosition3D(new Vector2(Mathf.Cos(rotA) * size, Mathf.Sin(rotA) * size), center);
Vector3 pointB = LightingPosition.GetPosition3D(new Vector2(Mathf.Cos(rotB) * size, Mathf.Sin(rotB) * size), center);
Gizmos.DrawLine(pointA, pointB);
if (angle < 360 && angle > 0)
{
if (i == start)
{
Gizmos.DrawLine(pointA, center);
}
if (i + step > end)
{
Gizmos.DrawLine(pointB, center);
}
}
}
}
static public void Render(Light2D light)
{
float size = light.size;
GL.PushMatrix();
if (light.IsPixelPerfect())
{
Camera camera = Camera.main;
float cameraRotation = LightingPosition.GetCameraRotation(camera);
Matrix4x4 matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0, 0, cameraRotation), Vector3.one);
float sizeY = camera.orthographicSize;
float sizeX = sizeY * ((float)camera.pixelWidth / camera.pixelHeight);
GL.LoadPixelMatrix(-sizeX, sizeX, -sizeY, sizeY);
}
else
{
GL.LoadPixelMatrix(-size, size, -size, size);
}
Rendering.Light.Main.Draw(light);
GL.PopMatrix();
}
public static void Render(LightingMainBuffer2D buffer)
{
Camera camera = buffer.cameraSettings.GetCamera();
if (camera == null)
{
return;
}
float cameraRotation = LightingPosition.GetCameraRotation(camera);
Matrix4x4 matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0, 0, cameraRotation), Vector3.one);
float sizeY = camera.orthographicSize;
float sizeX = sizeY * ((float)camera.pixelWidth / camera.pixelHeight);
GL.LoadPixelMatrix(-sizeX, sizeX, -sizeY, sizeY);
GL.MultMatrix(matrix);
GL.PushMatrix();
BufferPreset bufferPreset = buffer.GetBufferPreset();
Rendering.Day.Main.Draw(camera, bufferPreset);
Rendering.Night.Main.Draw(camera, bufferPreset);
GL.PopMatrix();
}
static public void DrawRect(Vector3 position, Rect rect)
{
Vector3 p0 = LightingPosition.GetPosition3DWorld(new Vector2(rect.x, rect.y), position);
Vector3 p1 = LightingPosition.GetPosition3DWorld(new Vector2(rect.x + rect.width, rect.y), position);
Vector3 p2 = LightingPosition.GetPosition3DWorld(new Vector2(rect.x + rect.width, rect.y + rect.height), position);
Vector3 p3 = LightingPosition.GetPosition3DWorld(new Vector2(rect.x, rect.y + rect.height), position);
Gizmos.DrawLine(p0, p1);
Gizmos.DrawLine(p1, p2);
Gizmos.DrawLine(p2, p3);
Gizmos.DrawLine(p3, p0);
}
public void Update()
{
if (camera == null)
{
return;
}
Transform transform = camera.transform;
Vector2 position2D = LightingPosition.GetPosition2D(transform.position);
Vector2 scale2D = transform.lossyScale;
float rotation2D = LightingPosition.GetRotation2D(transform);
float size2D = camera.orthographicSize;
bool update = false;
if (position != position2D)
{
position = position2D;
update = true;
}
if (scale != scale2D)
{
scale = scale2D;
update = true;
}
if (rotation != rotation2D)
{
rotation = rotation2D;
update = true;
}
if (size != size2D)
{
size = size2D;
update = true;
}
if (update)
{
worldPolygon = null;
}
}
private static void DarknessColor(Camera camera, BufferPreset bufferPreset)
{
Color color = bufferPreset.darknessColor;
if (color.a > 0)
{
Material material = Lighting2D.materials.GetAlphaBlend();
material.SetColor("_TintColor", color);
material.mainTexture = null;
float cameraRotation = -LightingPosition.GetCameraRotation(camera);
Universal.Texture.Draw(material, Vector2.zero, LightingRender2D.GetSize(camera), cameraRotation, 0);
}
}
public static void SetPass(Light2D lightObject, LayerSetting layer)
{
light = lightObject;
lightSize = Mathf.Sqrt(light.size * light.size + light.size * light.size);
lightOffset = -light.transform2D.position;
effectLayer = layer.shadowEffectLayer;
objectOffset = Vector2.zero;
effectPolygons.Clear();
softShadowObjects = layer.shadowEffect == LightLayerShadowEffect.SoftObjects;
softShadow = softShadowObjects || layer.shadowEffect == LightLayerShadowEffect.SoftVertex;
if (lightObject.IsPixelPerfect())
{
Camera camera = Camera.main;
Vector2 pos = LightingPosition.GetPosition2D(-camera.transform.position);
drawOffset = light.transform2D.position + pos;
}
else
{
drawOffset = Vector2.zero;
}
if (layer.shadowEffect == LightLayerShadowEffect.Projected)
{
drawMode = 2;
GenerateEffectLayers();
}
else if (softShadow)
{
drawMode = 1;
}
else if (layer.shadowEffect == LightLayerShadowEffect.SpriteProjection)
{
drawMode = 3;
}
else
{
drawMode = 0;
}
}
static public void DrawPolygon(Polygon2D polygon, Vector3 position)
{
Vector3 a = Vector3.zero;
Vector3 b = Vector3.zero;
for (int i = 0; i < polygon.pointsList.Count; i++)
{
Vector2D p0 = polygon.pointsList[i];
Vector2D p1 = polygon.pointsList[(i + 1) % polygon.pointsList.Count];
a = LightingPosition.GetPosition3DWorld(p0.ToVector2(), position);
b = LightingPosition.GetPosition3DWorld(p1.ToVector2(), position);
Gizmos.DrawLine(a, b);
}
}
static public void DrawPolygon(Polygon2 polygon, Vector3 position)
{
Vector3 a = Vector3.zero;
Vector3 b = Vector3.zero;
for (int i = 0; i < polygon.points.Length; i++)
{
Vector2 p0 = polygon.points[i];
Vector2 p1 = polygon.points[(i + 1) % polygon.points.Length];
a = LightingPosition.GetPosition3DWorld(p0, position);
b = LightingPosition.GetPosition3DWorld(p1, position);
Gizmos.DrawLine(a, b);
}
}
public void UpdatePosition()
{
Camera camera = mainBuffer.cameraSettings.GetCamera();
if (camera == null)
{
return;
}
transform.position = LightingPosition.GetCameraPlanePosition(camera);
transform.rotation = camera.transform.rotation;
// Local scale, not great
transform.localScale = LightingRender2D.GetSize(camera);
// transform.localScale = LightingRender2D.GetSize(camera);
}
static public void Draw(Light2D light, Camera camera)
{
if (light.Buffer == null)
{
return;
}
if (light.isActiveAndEnabled == false)
{
return;
}
if (light.InAnyCamera() == false)
{
return;
}
Vector2 pos = LightingPosition.GetPosition2D(-camera.transform.position);
Vector2 size = new Vector2(light.size, light.size);
if (light.IsPixelPerfect())
{
size = LightingRender2D.GetSize(camera);
pos = Vector2.zero;
}
else
{
pos += light.transform2D.position;
}
Color lightColor = light.color;
lightColor.a = light.color.a / 2;
Material material = Lighting2D.materials.GetLight();
material.mainTexture = light.Buffer.renderTexture.renderTexture;
material.SetColor("_TintColor", lightColor);
Rendering.Universal.Texture.Draw(material, pos, size, 0);
}
// Graphics.Draw() Mode Drawing
static public void PreRender(LightingMainBuffer2D mainBuffer)
{
Camera camera = mainBuffer.cameraSettings.GetCamera();
if (camera == null)
{
return;
}
if (mainBuffer.cameraSettings.renderMode == CameraSettings.RenderMode.Disabled)
{
return;
}
if (Lighting2D.RenderingMode != RenderingMode.OnPreRender)
{
return;
}
Graphics.DrawMesh(LightingRender2D.GetMesh(), Matrix4x4.TRS(LightingPosition.GetCameraPlanePosition(camera), camera.transform.rotation, GetSize(camera)), mainBuffer.GetMaterial(), 0, camera);
}
public void UpdateLight(Light2D id, MeshMode meshMode) // Camera
{
if (meshModeMaterial != meshMode.materials)
{
meshModeMaterial = meshMode.materials;
ClearMaterial();
}
if (meshModeShader != meshMode.shader)
{
meshModeShader = meshMode.shader;
ClearMaterial();
}
Material[] materials = GetMaterials();
if (materials == null)
{
return;
}
if (id.IsPixelPerfect())
{
Camera camera = Camera.main;
Vector2 cameraSize = LightingRender2D.GetSize(camera);
Vector2 cameraPosition = LightingPosition.GetPosition2D(-camera.transform.position);
transform.position = new Vector3(cameraPosition.x, cameraPosition.y, id.transform.position.z);
transform.localScale = new Vector3(cameraSize.x, cameraSize.y, 1);
}
else
{
transform.position = id.transform.position;
transform.localScale = new Vector3(id.size, id.size, 1);
}
transform.rotation = Quaternion.Euler(0, 0, 0);
// transform.rotation = id.transform.rotation; // only if rotation enabled
if (id.Buffer != null && meshRenderer != null)
{
Color lightColor = id.color;
lightColor.a = id.meshMode.alpha;
for (int i = 0; i < materials.Length; i++)
{
if (materials[i] == null)
{
continue;
}
materials[i].SetColor("_TintColor", lightColor);
materials[i].color = lightColor;
materials[i].mainTexture = id.Buffer.renderTexture.renderTexture;
}
id.meshMode.sortingLayer.ApplyToMeshRenderer(meshRenderer);
meshRenderer.sharedMaterials = GetMaterials();
meshRenderer.enabled = true;
meshFilter.mesh = GetMeshLight();
}
}
