public bool InCamera()
{
float cameraSize = LightingMainBuffer2D.Get().cameraSize;
Camera camera = LightingManager2D.Get().GetCamera();
return(Vector2.Distance(transform.position, camera.transform.position) < Mathf.Sqrt((cameraSize * 2f) * (cameraSize * 2f)) + shape.GetFrustumDistance(transform));
}
public void Initialize()
{
instance = this;
// Lighting Materials
additiveMaterial = new Material(Shader.Find(Max2D.shaderPath + "Particles/Additive"));
penumbraMaterial = new Material(Shader.Find(Max2D.shaderPath + "Particles/Multiply"));
penumbraMaterial.mainTexture = Resources.Load("textures/penumbra") as Texture;
occlusionEdgeMaterial = new Material(Shader.Find(Max2D.shaderPath + "Particles/Multiply"));
occlusionEdgeMaterial.mainTexture = Resources.Load("textures/occlusionedge") as Texture;
shadowBlurMaterial = new Material(Shader.Find(Max2D.shaderPath + "Particles/Multiply"));
shadowBlurMaterial.mainTexture = Resources.Load("textures/shadowblur") as Texture;
occlusionBlurMaterial = new Material(Shader.Find(Max2D.shaderPath + "Particles/Multiply"));
occlusionBlurMaterial.mainTexture = Resources.Load("textures/occlussionblur") as Texture;
whiteSpriteMaterial = new Material(Shader.Find("SmartLighting2D/SpriteWhite"));
blackSpriteMaterial = new Material(Shader.Find("SmartLighting2D/SpriteBlack"));
transform.position = Vector3.zero;
mainBuffer = LightingMainBuffer2D.Get();
fboManager = FBOManager.Get();
version = VERSION;
}
public void OnRenderObject()
{
if (enable == false)
{
return;
}
if (Camera.current != Camera.main)
{
return;
}
if (mainBuffer == null)
{
mainBuffer = LightingMainBuffer2D.Get();
return;
}
if (mainBuffer.bufferCamera == null)
{
return;
}
LightingDebug.LightMainCameraUpdates += 1;
float sizeX = mainBuffer.bufferCamera.orthographicSize * ((float)Screen.width / Screen.height);
Vector2 size = new Vector2(sizeX, mainBuffer.bufferCamera.orthographicSize);
size.x *= ((float)Screen.width / (float)Screen.height) / (size.x / size.y);
Vector3 pos = Camera.main.transform.position;
pos.z += 1;
Max2D.iDrawImage2(mainBuffer.material, pos, size, Camera.main.transform.eulerAngles.z, pos.z);
}
public bool InCamera()
{
float cameraSize = LightingMainBuffer2D.Get().cameraSize * 1.25f;
float verticalSize = cameraSize;
float horizontalSize = cameraSize * ((float)Screen.width / Screen.height);
Camera camera = LightingManager2D.Get().GetCamera();
return(Vector2.Distance(transform.position, camera.transform.position) < Mathf.Sqrt((verticalSize) * (horizontalSize)) + GetSize() * 2);
}
static public void DrawTint()
{
float ratio = (float)Screen.width / Screen.height;
Camera camera = LightingManager2D.Get().GetCamera();
Camera bufferCamera = LightingMainBuffer2D.Get().bufferCamera;
Vector2 size = new Vector2(bufferCamera.orthographicSize * ratio, bufferCamera.orthographicSize);
Vector3 pos = camera.transform.position;
LightingManager2D manager = LightingManager2D.Get();
Max2D.DrawImage(manager.materials.GetAdditive(), new Vector2D(pos), new Vector2D(size), pos.z);
}
public bool InCamera()
{
Camera camera = LightingManager2D.Get().GetCamera();
float cameraSize = LightingMainBuffer2D.Get().cameraSize;
if (camera == null)
{
return(false);
}
else
{
return(Vector2.Distance(transform.position, camera.transform.position) < Mathf.Sqrt((cameraSize * 2f) * (cameraSize * 2f)) + lightSize);
}
}
public void Initialize()
{
instance = this;
transform.position = Vector3.zero;
mainBuffer = LightingMainBuffer2D.Get();
fboManager = FBOManager.Get();
spriteAtlas = SpriteAtlasManager.Get();
meshRendererManager = MeshRendererManager.Get();
version = VERSION;
}
public bool Render_Check()
{
if (darknessBuffer == false)
{
return(false);
}
if (mainBuffer == null)
{
mainBuffer = LightingMainBuffer2D.Get();
return(false);
}
if (mainBuffer.bufferCamera == null)
{
return(false);
}
return(true);
}
void Start()
{
instance = this;
// Lighting Materials
additiveMaterial = new Material(Shader.Find("Particles/Additive"));
//additiveMaterial.mainTexture = Resources.Load ("textures/additive") as Texture;
penumbraMaterial = new Material(Shader.Find("Particles/Multiply"));
penumbraMaterial.mainTexture = Resources.Load("textures/penumbra") as Texture;
occlusionEdgeMaterial = new Material(Shader.Find("Particles/Multiply"));
occlusionEdgeMaterial.mainTexture = Resources.Load("textures/occlusionedge") as Texture;
shadowBlurMaterial = new Material(Shader.Find("Particles/Multiply"));
shadowBlurMaterial.mainTexture = Resources.Load("textures/shadowedge") as Texture;
transform.position = Vector3.zero;
mainBuffer = LightingMainBuffer2D.Get();
}
static public void OnGUI()
{
if (timer == null)
{
LightingDebug.timer = TimerHelper.Create();
}
if (timer.GetMillisecs() > 1000)
{
ShowLightBufferUpdates = LightBufferUpdates;
LightBufferUpdates = 0;
ShowLightMainBufferUpdates = LightMainBufferUpdates;
LightMainBufferUpdates = 0;
ShowLightMainCameraUpdates = LightMainCameraUpdates;
LightMainCameraUpdates = 0;
timer = TimerHelper.Create();
}
ShowLightSourceDrawn = LightSourceDrawn;
LightSourceDrawn = 0;
GUI.Label(new Rect(10, 10, 200, 20), "Light Buffer Updates: " + ShowLightBufferUpdates);
GUI.Label(new Rect(10, 30, 200, 20), "Light Main Buffer Updates: " + ShowLightMainBufferUpdates);
GUI.Label(new Rect(10, 50, 200, 20), "Light Main Camera Updates: " + ShowLightMainCameraUpdates);
GUI.Label(new Rect(10, 70, 200, 20), "Light Buffer Count: " + LightingBuffer2D.GetList().Count);
GUI.Label(new Rect(10, 90, 200, 20), "Light Collider Count: " + LightingCollider2D.GetList().Count);
Texture texture = LightingMainBuffer2D.Get().bufferCamera.activeTexture;
GUI.Label(new Rect(10, 110, 200, 20), "Main Buffer Resolution: " + texture.width + "x" + texture.height);
GUI.Label(new Rect(10, 130, 200, 20), "Light Sources Drawn: " + ShowLightSourceDrawn);
}
public static void Draw(Vector2D offset, float z)
{
float sunDirection = LightingManager2D.GetSunDirection();
// Day Soft Shadows
GL.PushMatrix();
Max2D.defaultMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
GL.Color(Color.black);
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
if (id.dayHeight == false || id.height <= 0)
{
continue;
}
if (id.colliderType == LightingCollider2D.ColliderType.Mesh)
{
continue;
}
List <Polygon2D> polygons = null;
switch (id.colliderType)
{
case LightingCollider2D.ColliderType.Collider:
polygons = id.GetColliderPolygons();
break;
case LightingCollider2D.ColliderType.SpriteCustomPhysicsShape:
polygons = id.GetShapePolygons();
break;
}
Polygon2D poly;
Vector3 vecA;
Vector3 vecB;
Vector3 vecC;
foreach (Polygon2D polygon in polygons)
{
poly = polygon.ToWorldSpace(id.gameObject.transform);
Polygon2D convexHull = Polygon2D.GenerateShadow(new Polygon2D(poly.pointsList), sunDirection, id.height);
Mesh mesh = convexHull.CreateMesh(Vector2.zero, Vector2.zero);
for (int i = 0; i < mesh.triangles.GetLength(0); i = i + 3)
{
vecA = mesh.vertices [mesh.triangles [i]];
vecB = mesh.vertices [mesh.triangles [i + 1]];
vecC = mesh.vertices [mesh.triangles [i + 2]];
Max2DMatrix.DrawTriangle(vecA.x, vecA.y, vecB.x, vecB.y, vecC.x, vecC.y, offset, z);
}
}
}
GL.End();
GL.PopMatrix();
GL.PushMatrix();
// Null Check?
LightingManager2D.Get().shadowBlurMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
Max2D.SetColor(Color.white);
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
if (id.dayHeight == false || id.height <= 0)
{
continue;
}
if (id.colliderType == LightingCollider2D.ColliderType.Mesh)
{
continue;
}
List <Polygon2D> polygons = null;
switch (id.colliderType)
{
case LightingCollider2D.ColliderType.Collider:
polygons = id.GetColliderPolygons();
break;
case LightingCollider2D.ColliderType.SpriteCustomPhysicsShape:
polygons = id.GetShapePolygons();
break;
}
foreach (Polygon2D polygon in polygons)
{
Polygon2D poly = polygon.ToWorldSpace(id.gameObject.transform);
Polygon2D convexHull = Polygon2D.GenerateShadow(new Polygon2D(poly.pointsList), sunDirection, id.height);
foreach (DoublePair2D p in DoublePair2D.GetList(convexHull.pointsList))
{
Vector2D zA = new Vector2D(p.A + offset);
Vector2D zB = new Vector2D(p.B + offset);
Vector2D zC = zB.Copy();
Vector2D pA = zA.Copy();
Vector2D pB = zB.Copy();
zA.Push(Vector2D.Atan2(p.A, p.B) + pi2, .5f);
zB.Push(Vector2D.Atan2(p.A, p.B) + pi2, .5f);
zC.Push(Vector2D.Atan2(p.B, p.C) + pi2, .5f);
GL.TexCoord2(uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pA, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(zA, z);
GL.TexCoord2(uv0, uv1);
Max2D.Vertex3(zA, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(zB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(uv0, uv1);
Max2D.Vertex3(zB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(zC, z);
}
}
}
GL.End();
GL.PopMatrix();
#if UNITY_2018_1_OR_NEWER
GL.PushMatrix();
Max2D.defaultMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
GL.Color(Color.black);
// Day Soft Shadows
foreach (LightingTilemapCollider2D id in LightingTilemapCollider2D.GetList())
{
if (id.map == null)
{
continue;
}
if (id.dayHeight == false)
{
continue;
}
for (int x = 0; x < id.area.size.x; x++)
{
for (int y = 0; y < id.area.size.y; y++)
{
if (id.map[x, y] == null)
{
DrawSoftShadowTile(offset + new Vector2D(x, y), z, id.height);
}
}
}
}
GL.End();
GL.PopMatrix();
GL.PushMatrix();
LightingManager2D.Get().shadowBlurMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
Max2D.SetColor(Color.white);
// Day Soft Shadows
foreach (LightingTilemapCollider2D id in LightingTilemapCollider2D.GetList())
{
if (id.map == null)
{
continue;
}
if (id.dayHeight == false)
{
continue;
}
for (int x = 0; x < id.area.size.x; x++)
{
for (int y = 0; y < id.area.size.y; y++)
{
if (id.map[x, y] == null)
{
DrawSoftShadowTileBlur(offset + new Vector2D(x, y), z, id.height);
}
}
}
}
GL.End();
GL.PopMatrix();
#endif
/*
*
* Material material = LightingManager2D.Get().whiteSpriteMaterial;
* foreach (LightingSprite2D id in LightingSprite2D.GetList()) {
* if (id.GetSpriteRenderer() == null) {
* continue;
* }
* material.mainTexture = id.GetSpriteRenderer().sprite.texture; //Debug.Log(sprite.pivot);
*
* Vector2 p = id.transform.position;
* Vector2 scale = id.transform.lossyScale;
*
* if (id.GetSpriteRenderer().flipX) {
* scale.x = -scale.x;
* }
*
* if (id.GetSpriteRenderer().flipY) {
* scale.y = -scale.y;
* }
*
* Max2D.DrawImage(material, offset.ToVector2() + p, scale, id.transform.rotation.eulerAngles.z, z);
* } */
float ratio = (float)Screen.width / Screen.height;
Camera bufferCamera = LightingMainBuffer2D.Get().bufferCamera;
Vector2 size = new Vector2(bufferCamera.orthographicSize * ratio, bufferCamera.orthographicSize);
Vector3 pos = Camera.main.transform.position;
Max2D.DrawImage(LightingManager2D.Get().additiveMaterial, new Vector2D(pos), new Vector2D(size), pos.z);
// Day Lighting Masking
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
if (id.generateDayMask == false)
{
continue;
}
switch (id.maskType)
{
case LightingCollider2D.MaskType.SpriteCustomPhysicsShape:
Max2D.SetColor(Color.white);
Max2D.DrawMesh(Max2D.defaultMaterial, id.GetShapeMesh(), id.transform, offset, z);
break;
case LightingCollider2D.MaskType.Collider:
Max2D.SetColor(Color.white);
Max2D.DrawMesh(Max2D.defaultMaterial, id.GetColliderMesh(), id.transform, offset, z);
break;
case LightingCollider2D.MaskType.Sprite:
if (id.spriteRenderer == null || id.spriteRenderer.sprite == null)
{
break;
}
Material material = LightingManager2D.Get().whiteSpriteMaterial;
material.mainTexture = id.spriteRenderer.sprite.texture;
Max2D.DrawSprite(material, id.spriteRenderer, new Vector2(id.transform.position.x, id.transform.position.y) + offset.ToVector2(), new Vector2(1, 1), id.transform.rotation.eulerAngles.z, z);
break;
}
}
}
static public void OnGUI()
{
if (timer == null)
{
LightingDebug.timer = TimerHelper.Create();
}
if (timer.GetMillisecs() > 1000)
{
ShowLightBufferUpdates = LightBufferUpdates;
LightBufferUpdates = 0;
ShowLightMainBufferUpdates = LightMainBufferUpdates;
LightMainBufferUpdates = 0;
ShowLightMainCameraUpdates = LightMainCameraUpdates;
LightMainCameraUpdates = 0;
timer = TimerHelper.Create();
}
if (SpriteRenderersDrawn > 0)
{
ShowSpriteRenderersDrawn = SpriteRenderersDrawn;
SpriteRenderersDrawn = 0;
}
int count = 0;
foreach (LightingSource2D light in LightingSource2D.GetList())
{
if (light.InCamera() == false)
{
continue;
}
count++;
}
GUI.Label(new Rect(10, 10, 500, 20), "Lights in Camera: " + count + "/" + LightingSource2D.GetList().Count);
GUI.Label(new Rect(10, 30, 500, 20), "Free Buffers: " + FBOManager.GetFreeCount() + "/" + FBOManager.GetList().Count);
GUI.Label(new Rect(10, 50, 500, 20), "Light Buffer Updates: " + ShowLightBufferUpdates);
GUI.Label(new Rect(10, 70, 500, 20), "Total Light Updates: " + totalLightUpdates);
GUI.Label(new Rect(10, 90, 500, 20), "=========================");
GUI.Label(new Rect(10, 110, 500, 20), "Mask Generations: " + maskGenerations);
GUI.Label(new Rect(10, 130, 500, 20), "Shadow Generations: " + shadowGenerations);
GUI.Label(new Rect(10, 150, 500, 20), "Penumbra Generations: " + penumbraGenerations);
GUI.Label(new Rect(10, 170, 500, 20), "Objects Culled: " + culled);
GUI.Label(new Rect(10, 190, 500, 20), "=========================");
GUI.Label(new Rect(10, 210, 500, 20), "Sprite Renderers Drawn: " + ShowSpriteRenderersDrawn);
GUI.Label(new Rect(10, 230, 500, 20), "=========================");
GUI.Label(new Rect(10, 250, 500, 20), "Light Main Buffer Updates: " + ShowLightMainBufferUpdates);
GUI.Label(new Rect(10, 270, 500, 20), "Light Main Camera Updates: " + ShowLightMainCameraUpdates);
GUI.Label(new Rect(10, 290, 500, 20), "=========================");
Texture texture = LightingMainBuffer2D.Get().bufferCamera.activeTexture;
if (texture != null)
{
GUI.Label(new Rect(10, 310, 500, 20), "Main Buffer Resolution: " + texture.width + "x" + texture.height);
}
else
{
GUI.Label(new Rect(10, 330, 500, 20), "Main Buffer Resolution: NULL");
}
GUI.Label(new Rect(10, 350, 500, 20), "Glow Particles Generated: " + BlurManager.dictionary.Count);
GUIStyle style = new GUIStyle();
style.alignment = TextAnchor.LowerRight;
style.normal.textColor = Color.white;
style.fontSize = 13;
#if UNITY_2018_1_OR_NEWER
Object[] tilemaps = Object.FindObjectsOfType(typeof(LightingTilemapCollider2D));
#endif
Object[] lights = Object.FindObjectsOfType(typeof(LightingSource2D));
Object[] colliders = Object.FindObjectsOfType(typeof(LightingCollider2D));
Object[] sprites = Object.FindObjectsOfType(typeof(LightingSpriteRenderer2D));
#if UNITY_2018_1_OR_NEWER
GUI.Label(new Rect(0, -10, Screen.width - 10, Screen.height), "Tilemap Collider Count: " + tilemaps.Length, style);
#endif
GUI.Label(new Rect(0, -30, Screen.width - 10, Screen.height), "Lights Count: " + lights.Length, style);
GUI.Label(new Rect(0, -50, Screen.width - 10, Screen.height), "Colliders Count: " + colliders.Length, style);
GUI.Label(new Rect(0, -70, Screen.width - 10, Screen.height), "Sprites Count: " + sprites.Length, style);
}
public void UpdateMainBuffers() {
for(int i = 0; i < cameraSettings.Length; i++) {
CameraSettings cameraSetting = cameraSettings[i];
if (cameraSetting.renderMode == CameraSettings.RenderMode.Disabled) {
continue;
}
LightingMainBuffer2D buffer = LightingMainBuffer2D.Get(cameraSetting);
if (buffer != null) {
buffer.cameraSettings.renderMode = cameraSetting.renderMode;
buffer.cameraSettings.renderLayerId = cameraSetting.renderLayerId;
if (buffer.cameraSettings.customMaterial != cameraSetting.customMaterial) {
buffer.cameraSettings.customMaterial = cameraSetting.customMaterial;
buffer.ClearMaterial();
}
if (buffer.cameraSettings.renderShader != cameraSetting.renderShader) {
buffer.cameraSettings.renderShader = cameraSetting.renderShader;
buffer.ClearMaterial();
}
foreach(Material material in cameraSetting.GetMaterials().materials) {
if (material == null) {
continue;
}
Camera camera = cameraSetting.GetCamera();
if (cameraSetting.cameraType == CameraSettings.CameraType.SceneView) {
CameraMaterials.SetMaterial(2, material, camera, buffer.renderTexture);
} else {
CameraMaterials.SetMaterial(1, material, camera, buffer.renderTexture);
}
}
}
}
for(int i = 0; i < LightingMainBuffer2D.List.Count; i++) {
LightingMainBuffer2D buffer = LightingMainBuffer2D.List[i];
if (buffer != null) {
buffer.Update();
}
}
if (LightingMainBuffer2D.List.Count > 0) {
foreach(LightingMainBuffer2D buffer in LightingMainBuffer2D.List) {
if (Lighting2D.disable) {
buffer.updateNeeded = false;
return;
}
CameraSettings cameraSettings = buffer.cameraSettings;
bool render = cameraSettings.renderMode != CameraSettings.RenderMode.Disabled;
if (render && cameraSettings.GetCamera() != null) {
buffer.updateNeeded = true;
} else {
buffer.updateNeeded = false;
}
}
}
}
public static void Draw(Vector2D offset, float z)
{
float sunDirection = LightingManager2D.GetSunDirection();
// Day Soft Shadows
GL.PushMatrix();
Max2D.defaultMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
GL.Color(Color.black);
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
if (id.dayHeight == false || id.height <= 0)
{
continue;
}
List <Polygon2D> polygons = id.GetPolygons();
foreach (Polygon2D polygon in polygons)
{
Polygon2D poly = polygon;
poly = poly.ToWorldSpace(id.gameObject.transform);
foreach (Pair2D p in Pair2D.GetList(poly.pointsList))
{
Vector2D vA = p.A.Copy();
Vector2D vB = p.B.Copy();
vA.Push(sunDirection, id.height);
vB.Push(sunDirection, id.height);
Max2DMatrix.DrawTriangle(p.A, p.B, vA, offset, z);
Max2DMatrix.DrawTriangle(vA, vB, p.B, offset, z);
}
}
}
GL.End();
GL.PopMatrix();
GL.PushMatrix();
LightingManager2D.Get().shadowBlurMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
Max2D.SetColor(Color.white);
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
if (id.dayHeight == false || id.height <= 0)
{
continue;
}
List <Polygon2D> polygons = id.GetPolygons();
foreach (Polygon2D polygon in polygons)
{
Polygon2D poly = polygon;
poly = poly.ToWorldSpace(id.gameObject.transform);
Polygon2D convexHull = Polygon2D.GenerateShadow(new Polygon2D(poly.pointsList), sunDirection, id.height);
foreach (DoublePair2D p in DoublePair2D.GetList(convexHull.pointsList))
{
Vector2D zA = new Vector2D(p.A + offset);
Vector2D zB = new Vector2D(p.B + offset);
Vector2D zC = zB.Copy();
Vector2D pA = zA.Copy();
Vector2D pB = zB.Copy();
zA.Push(Vector2D.Atan2(p.A, p.B) + pi2, .5f);
zB.Push(Vector2D.Atan2(p.A, p.B) + pi2, .5f);
zC.Push(Vector2D.Atan2(p.B, p.C) + pi2, .5f);
GL.TexCoord2(uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pA, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(zA, z);
GL.TexCoord2(uv0, uv1);
Max2D.Vertex3(zA, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(zB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(uv0, uv1);
Max2D.Vertex3(zB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(zC, z);
}
}
}
GL.End();
GL.PopMatrix();
GL.PushMatrix();
Max2D.defaultMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
GL.Color(Color.black);
GL.End();
GL.PopMatrix();
GL.PushMatrix();
LightingManager2D.Get().shadowBlurMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
Max2D.SetColor(Color.white);
GL.End();
GL.PopMatrix();
Material material = LightingManager2D.Get().whiteSpriteMaterial;
foreach (LightingSprite2D id in LightingSprite2D.GetList())
{
if (id.GetSpriteRenderer() == null)
{
continue;
}
material.mainTexture = id.GetSpriteRenderer().sprite.texture; //Debug.Log(sprite.pivot);
Vector2 p = id.transform.position;
Vector2 scale = id.transform.lossyScale;
if (id.GetSpriteRenderer().flipX)
{
scale.x = -scale.x;
}
if (id.GetSpriteRenderer().flipY)
{
scale.y = -scale.y;
}
Max2D.DrawImage(material, offset.ToVector2() + p, scale, id.transform.rotation.eulerAngles.z, z);
}
material = LightingManager2D.Get().additiveMaterial;
foreach (LightingSpriteRenderer2D id in LightingSpriteRenderer2D.GetList())
{
if (id.sprite == null)
{
continue;
}
material.mainTexture = id.sprite.texture; //Debug.Log(sprite.pivot);
Vector2 position = id.transform.position;
Vector2 scale = id.transform.lossyScale;
float scaleX = (float)id.sprite.texture.width / (id.sprite.pixelsPerUnit * 2);
float scaleY = (float)id.sprite.texture.width / (id.sprite.pixelsPerUnit * 2);
//Debug.Log(scaleX + " " + scaleY);
scale.x *= scaleX;
scale.y *= scaleY;
scale.x *= id.scale.x;
scale.y *= id.scale.y;
if (id.flipX)
{
scale.x = -scale.x;
}
if (id.flipY)
{
scale.y = -scale.y;
}
//material.color = id.color;
Color color = id.color;
color.a = id.alpha;
material.SetColor("_TintColor", color);
Max2D.DrawImage(material, offset.ToVector2() + position + id.offset, scale, id.transform.rotation.eulerAngles.z, z);
}
material.mainTexture = null;
float ratio = (float)Screen.width / Screen.height;
Camera bufferCamera = LightingMainBuffer2D.Get().bufferCamera;
Vector2 size = new Vector2(bufferCamera.orthographicSize * ratio, bufferCamera.orthographicSize);
Vector3 pos = Camera.main.transform.position;
Max2D.iDrawImage(LightingManager2D.Get().additiveMaterial, new Vector2D(pos), new Vector2D(size), pos.z);
}
static public void OnGUI()
{
if (lights == null)
{
lights = Object.FindObjectsOfType(typeof(LightingSource2D));
colliders = Object.FindObjectsOfType(typeof(LightingCollider2D));
sprites = Object.FindObjectsOfType(typeof(LightingSpriteRenderer2D));
tilemaps = Object.FindObjectsOfType(typeof(LightingTilemapCollider2D));
}
if (timer == null)
{
LightingDebug.timer = TimerHelper.Create();
}
if (timer.GetMillisecs() > 1000)
{
SecondUpdate();
}
ShowUpdate();
int count = 0;
foreach (LightingSource2D light in LightingSource2D.GetList())
{
if (light.InCamera() == false)
{
continue;
}
count++;
}
LightingManager2D manager2D = LightingManager2D.Get();
int y = 10;
GUI.Label(new Rect(10, y, 500, 20), "Camera Size: " + manager2D.mainBuffer.cameraSize);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "New Render Textures: " + NewRenderTextures);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Lights in Camera: " + count + "/" + LightingSource2D.GetList().Count);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Free Buffers: " + FBOManager.GetFreeCount() + "/" + FBOManager.GetList().Count);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Light Buffer Updates: " + ShowLightBufferUpdates); // In Frame
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Total Light Updates: " + totalLightUpdates);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "=========================");
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Mask Generations: " + show_maskGenerations);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Shadow Generations: " + show_shadowGenerations);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Objects Culled: " + show_culled);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "=========================");
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Shadow Collider World Generations C: " + ShadowColliderTotalGenerationsWorld_collider + " (re: " + ShadowColliderTotalGenerationsWorld_collider_re + ") Pair: " + LightingDebug.ShadowColliderTotalGenerationsWorld_collider_pair);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Shadow Collider Local Generations C: " + ShadowColliderTotalGenerationsLocal_collider);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Shadow Collider World Generations S: " + ShadowColliderTotalGenerationsWorld_shape + " (re: " + ShadowColliderTotalGenerationsWorld_shape_re + ") Pair: " + LightingDebug.ShadowColliderTotalGenerationsWorld_shape_pair);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Shadow Collider Local Generations S: " + ShadowColliderTotalGenerationsLocal_shape);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Total Object SHAPE Generations: " + totalObjectMaskShapeGenerations);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Total Object MESH Generations : " + totalObjectMaskMeshGenerations);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "=========================");
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Convex Hull Generations: " + ShowConvexHullGenerations);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "=========================");
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Sprite Renderers Drawn: " + ShowSpriteRenderersDrawn);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "=========================");
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Light Main Buffer Updates: " + ShowLightMainBufferUpdates);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Light Main Camera Updates: " + ShowLightMainCameraUpdates);
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "=========================");
y += 10;
Texture texture = LightingMainBuffer2D.Get().bufferCamera.activeTexture;
if (texture != null)
{
GUI.Label(new Rect(10, y, 500, 20), "Main Buffer Resolution: " + texture.width + "x" + texture.height);
}
else
{
GUI.Label(new Rect(10, y, 500, 20), "Main Buffer Resolution: NULL");
}
y += 10;
GUI.Label(new Rect(10, y, 500, 20), "Glow Particles Generated: " + BlurManager.dictionary.Count);
RightBottomPanel();
}