public static void DrawShadowsAndMask(LightingBuffer2D buffer, int layer)
{
buffer.CalculateCoords();
drawMask = false;
if (buffer.lightSource.layerSetting[layer].type != LightingLayerType.ShadowOnly)
{
drawMask = true;
}
drawShadows = false;
if (buffer.lightSource.layerSetting[layer].type != LightingLayerType.MaskOnly)
{
drawShadows = true;
}
GL.PushMatrix();
if (LightingManager2D.Get().lightingSpriteAtlas&& SpriteAtlasManager.Get().atlasTexture != null)
{
DrawWithAtlas(buffer, layer);
}
else
{
DrawWithoutAtlas(buffer, layer);
}
GL.PopMatrix();
}
protected override void OnLoad(EventArgs e)
{
// Initialize GL State
GPUCapabilities.Initialize();
GL.ClearColor(0.25f, 0.25f, 0.25f, 1.0f);
// Set up PackageManager
PackageManager.BasePath = "../../Assets/";
// Initialize camera. Rest is in OnResize()
orthoCamera = new Camera(this);
orthoCamera.SetAsCurrent();
// Load shaders
ShaderManager.LoadCollection("Shaders/collection.xml");
// Initialize batch and atlas manager
spriteBatch = new SpriteBatch();
sam = new SpriteAtlasManager();
// Temporary example until editor gets sprite support
// Uncomment to regenerate sprite file
//GenerateSpriteFile();
// Get the sprite atlas
spaceShips = sam.Get("Sprites/SpaceShips.spr", true);
// Get sprite by ID (slow operation, cache result on load)
spaceShip = spaceShips["PlayerBlue1"];
}
public Sprite GetAtlasWhiteMaskSprite()
{
if (atlasWhiteMaskSprite == null)
{
atlasWhiteMaskSprite = SpriteAtlasManager.RequestSprite(GetWhiteMaskSprite(), SpriteRequest.Type.WhiteMask);
}
return(atlasWhiteMaskSprite);
}
public Sprite GetAtlasPenumbraSprite()
{
if (atlasPenumbraSprite == null)
{
atlasPenumbraSprite = SpriteAtlasManager.RequestSprite(GetPenumbraSprite(), SpriteRequest.Type.BlackAlpha);
}
return(atlasPenumbraSprite);
}
public CustomPhysicsShape GetPhysicsShape()
{
if (customPhysicsShape == null)
{
customPhysicsShape = SpriteAtlasManager.RequesCustomShape(originalSprite);
}
return(customPhysicsShape);
}
private void Awake()
{
if (Instance == null)
{
SpriteAtlasManager _saM = new SpriteAtlasManager();
_saM.Bind();
Instance = this;
}
}
private void Loading_Enter()
{
World.Load((World payload) =>
{
_world = payload;
});
// this uses AppManager.AssetManager
SpriteAtlasManager.Load();
}
static public void MaskSpriteDepthWithAtlas(LightingBuffer2D buffer, LightingTile tile, LayerSetting layerSetting, LightingTilemapCollider2D id, Vector2D offset, float z)
{
if (id.maskType != LightingTilemapCollider2D.MaskType.Sprite)
{
return;
}
if (id.maskType == LightingTilemapCollider2D.MaskType.None)
{
return;
}
if (tile.GetOriginalSprite() == null)
{
return;
}
Sprite sprite = tile.GetAtlasSprite();
Vector2 scale = new Vector2(1, 1);
if (sprite == null)
{
Sprite reqSprite = SpriteAtlasManager.RequestSprite(tile.GetOriginalSprite(), SpriteRequest.Type.WhiteMask);
if (reqSprite == null)
{
PartiallyBatched_Tilemap batched = new PartiallyBatched_Tilemap();
batched.virtualSpriteRenderer = new VirtualSpriteRenderer();
batched.virtualSpriteRenderer.sprite = tile.GetOriginalSprite();
batched.polyOffset = offset.ToVector2();
batched.tileSize = scale;
batched.tilemap = id;
buffer.partiallyBatchedList_Tilemap.Add(batched);
return;
}
else
{
tile.SetAtlasSprite(reqSprite);
sprite = reqSprite;
}
}
VirtualSpriteRenderer spriteRenderer = new VirtualSpriteRenderer();
spriteRenderer.sprite = sprite;
Max2D.DrawSpriteBatched_Tris(spriteRenderer, layerSetting, id.maskMode, offset.ToVector2(), scale, id.transform.rotation.eulerAngles.z, z);
LightingDebug.maskGenerations++;
}
public Material GetAtlasMaterial()
{
if (atlasMaterial == null)
{
atlasMaterial = new Material(Shader.Find(Max2D.shaderPath + "Particles/Alpha Blended"));
}
atlasMaterial.mainTexture = SpriteAtlasManager.Get().atlasTexture.texture;
return(atlasMaterial);
}
void Awake()
{
atlasTexture.texture = new Texture2D(2048, 2048);
for (int x = 0; x < atlasTexture.texture.width; x++)
{
for (int y = 0; y < atlasTexture.texture.height; y++)
{
atlasTexture.texture.SetPixel(x, y, new Color(0, 0, 0, 0));
}
}
atlasTexture.texture.Apply();
normal_dictionary_Sprite = new Dictionary <Sprite, Sprite>();
whiteMask_dictionary_Sprite = new Dictionary <Sprite, Sprite>();
blackMask_dictionary_Sprite = new Dictionary <Sprite, Sprite>();
normal_spriteList = new List <Sprite>();
whiteMask_spriteList = new List <Sprite>();
blackMask_spriteList = new List <Sprite>();
instance = this;
atlasTexture.currentX = 0;
atlasTexture.currentY = 0;
atlasTexture.currentHeight = 0;
// #if UNITY_EDITOR
// Debug.Log(2);
// #else
// Debug.Log(1);
// #endif
LightingManager2D manager = LightingManager2D.Get();
for (int i = 1; i <= manager.spriteAtlasPreloadFoldersCount; i++)
{
string folder = manager.spriteAtlasPreloadFolders[i - 1];
object[] sprites = Resources.LoadAll(folder, typeof(Sprite));
foreach (object obj in sprites)
{
Sprite sprite = (Sprite)obj;
RequestAccess(sprite, SpriteRequest.Type.WhiteMask);
}
}
// #endif
}
public void Initialize()
{
instance = this;
transform.position = Vector3.zero;
mainBuffer = LightingMainBuffer2D.Get();
fboManager = FBOManager.Get();
spriteAtlas = SpriteAtlasManager.Get();
meshRendererManager = MeshRendererManager.Get();
version = VERSION;
}
public static int constructor(IntPtr l)
{
int result;
try
{
SpriteAtlasManager o = new SpriteAtlasManager();
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, o);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
List <Sprite> ScanGameObject(GameObject obj)
{
List <Sprite> single = new List <Sprite>();
if (obj != null)
{
SpriteReferenceInfo.ScanGameObjectSprite(obj, (o, s, p) => {
string key = GetSpriteKey(s);
List <SpriteReferenceInfo.GameObjectInfo> _refs;
if (!refInfo.TryGetValue(key, out _refs))
{
_refs = new List <SpriteReferenceInfo.GameObjectInfo>();
refInfo[key] = _refs;
var oi = _refs.Find((i) => i.obj == obj);
if (oi == null)
{
var info = new SpriteReferenceInfo.GameObjectInfo(obj);
info.paths.Add(p);
_refs.Add(info);
}
else
{
oi.paths.Add(p);
}
}
SpriteAtlasData a = SpriteAtlasManager.Get(s.texture);
if (a != null)
{
if (!atlas.Contains(a))
{
atlas.Add(a);
}
}
else
{
if (!single.Contains(s))
{
single.Add(s);
}
}
});
}
return(single);
}
static public Sprite RequestSprite(Sprite originalSprite, SpriteRequest.Type type)
{
if (originalSprite == null)
{
return(null);
}
instance = Get();
Sprite spriteObject = null;
Dictionary <Sprite, Sprite> dictionary = null;
switch (type)
{
case SpriteRequest.Type.BlackAlpha:
dictionary = instance.normal_dictionary_Sprite;
break;
case SpriteRequest.Type.WhiteMask:
dictionary = instance.whiteMask_dictionary_Sprite;
break;
case SpriteRequest.Type.Normal:
dictionary = instance.blackMask_dictionary_Sprite;
break;
}
bool exist = dictionary.TryGetValue(originalSprite, out spriteObject);
if (exist)
{
if (spriteObject == null || spriteObject.texture == null)
{
instance.requestList.Add(new SpriteRequest(originalSprite, type));
return(null);
}
return(spriteObject);
}
else
{
instance.requestList.Add(new SpriteRequest(originalSprite, type));
return(null);
}
}
static public void DrawShadowsAndMask(LightingBuffer2D buffer, int layer)
{
buffer.CalculateCoords();
offset.x = -buffer.lightSource.transform.position.x;
offset.y = -buffer.lightSource.transform.position.y;
manager = LightingManager2D.Get();
layerSettings = buffer.lightSource.layerSetting[layer];
z = buffer.transform.position.z;
lightSizeSquared = Mathf.Sqrt(buffer.lightSource.lightSize * buffer.lightSource.lightSize + buffer.lightSource.lightSize * buffer.lightSource.lightSize);
SortObjects(buffer, layer);
drawMask = false;
if (buffer.lightSource.layerSetting[layer].type != LightingLayerType.ShadowOnly)
{
drawMask = true;
}
drawShadows = false;
if (buffer.lightSource.layerSetting[layer].type != LightingLayerType.MaskOnly)
{
drawShadows = true;
}
GL.PushMatrix();
if (manager.lightingSpriteAtlas && SpriteAtlasManager.Get().atlasTexture != null)
{
DrawWithAtlas(buffer, layer);
}
else
{
DrawWithoutAtlas(buffer, layer);
}
GL.PopMatrix();
}
public List <Polygon2D> GetShapePolygons()
{
if (shapePolygons == null)
{
shapePolygons = new List <Polygon2D>();
if (originalSprite == null)
{
return(shapePolygons);
}
#if UNITY_2018_1_OR_NEWER
if (customPhysicsShape == null)
{
customPhysicsShape = SpriteAtlasManager.RequesCustomShape(originalSprite);
}
shapePolygons = customPhysicsShape.GetShape();
#endif
}
return(shapePolygons);
}
//////////////////// CUSTOM PHYSICS SHAPE ////////////////////////////////
static public CustomPhysicsShape RequesCustomShape(Sprite originalSprite)
{
instance = Get();
CustomPhysicsShape shape = null;
bool exist = instance.dictionary_CustomShape.TryGetValue(originalSprite, out shape);
if (exist)
{
if (shape == null || shape.sprite.texture == null)
{
shape = RequestCustomShapeAccess(originalSprite);
}
return(shape);
}
else
{
shape = RequestCustomShapeAccess(originalSprite);
return(shape);
}
}
///////////////////////////////////////////////////////////////////////////////////
public static SpriteAtlasManager Get()
{
if (instance != null)
{
return(instance);
}
foreach (SpriteAtlasManager meshModeObject in Object.FindObjectsOfType(typeof(SpriteAtlasManager)))
{
instance = meshModeObject;
return(instance);
}
if (instance == null)
{
GameObject spriteAtlas = new GameObject("Sprite Atlas");
instance = spriteAtlas.AddComponent <SpriteAtlasManager>();
LightingManager2D manager = LightingManager2D.Get();
spriteAtlas.transform.parent = manager.transform;
}
return(instance);
}
protected override DragAndDropVisualMode HandleDragAndDrop(DragAndDropArgs args)
{
if (args.parentItem == null)
{
return(DragAndDropVisualMode.Rejected);
}
// if (args.parentItem.id == -1) return DragAndDropVisualMode.Rejected;
SpriteAtlasData atlas;
SpriteAtlasData.SpriteInfo sprite;
Sprite origin;
Get(args.parentItem.id, out atlas, out sprite, out origin);
List <Texture2D> draging_atlas = new List <Texture2D>();
Object[] objs = DragAndDrop.objectReferences;
List <Sprite> sprites = new List <Sprite>();
foreach (var obj in DragAndDrop.objectReferences)
{
Sprite s = null;
if (obj.GetType() == typeof(Sprite))
{
s = obj as Sprite;
}
else if (obj.GetType() == typeof(Texture2D))
{
TextureImporter importer = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(obj)) as TextureImporter;
if (importer.textureType != TextureImporterType.Sprite)
{
continue;
}
if (importer.spriteImportMode == SpriteImportMode.Multiple)
{
draging_atlas.Add(obj as Texture2D);
continue;
}
else
{
s = AssetDatabase.LoadAssetAtPath <Sprite>(AssetDatabase.GetAssetPath(obj));
}
}
if (s == null || s.texture == atlas.texture)
{
continue;
}
if (atlas.HaveSprite(s.name))
{
continue;
}
sprites.Add(s);
}
if (atlas == null)
{
if (draging_atlas.Count == 0)
{
return(DragAndDropVisualMode.Rejected);
}
}
else
{
if (sprites.Count == 0)
{
return(DragAndDropVisualMode.Rejected);
}
}
if (!args.performDrop)
{
return(DragAndDropVisualMode.Copy);
}
if (atlas == null)
{
foreach (Texture2D tex in draging_atlas)
{
SpriteAtlasData spriteAtlasData = SpriteAtlasManager.Get(tex);
if (!atlasList.Contains(spriteAtlasData))
{
atlasList.Add(spriteAtlasData);
}
}
}
else
{
foreach (Sprite s in sprites)
{
atlas.AddSprite(s);
}
}
DragAndDrop.AcceptDrag();
Reload();
return(DragAndDropVisualMode.Copy);
}
static public void DrawWithAtlas(Vector2D offset, float z)
{
material = manager.materials.GetAdditive();
material.SetColor("_TintColor", Color.white);
material.mainTexture = SpriteAtlasManager.Get().atlasTexture.texture;
material.SetPass(0);
GL.Begin(GL.TRIANGLES);
for (int i = 0; i < spriteRendererList.Count; i++)
{
id = spriteRendererList[i];
if (id.type != LightingSpriteRenderer2D.Type.Particle)
{
continue;
}
if (id.GetSprite() == null)
{
continue;
}
if (id.InCamera() == false)
{
continue;
}
position = id.transform.position;
scale = id.transform.lossyScale;
scale.x *= id.offsetScale.x;
scale.y *= id.offsetScale.y;
rot = id.offsetRotation;
if (id.applyTransformRotation)
{
rot += id.transform.rotation.eulerAngles.z;
}
color = id.color;
color.a = id.alpha;
GL.Color(color);
spriteRenderer.sprite = SpriteAtlasManager.RequestSprite(id.GetSprite(), SpriteRequest.Type.Normal);
Max2D.DrawSpriteBatched_Tris_Day(spriteRenderer, offset.ToVector2() + position + id.offsetPosition, scale, rot, z);
LightingDebug.SpriteRenderersDrawn++;
}
GL.End();
material = manager.materials.GetAtlasMaterial();
material.SetPass(0);
GL.Begin(GL.TRIANGLES);
for (int i = 0; i < spriteRendererList.Count; i++)
{
id = spriteRendererList[i];
if (id.type == LightingSpriteRenderer2D.Type.Particle)
{
continue;
}
if (id.GetSprite() == null)
{
continue;
}
if (id.InCamera() == false)
{
continue;
}
position = id.transform.position;
scale = id.transform.lossyScale;
scale.x *= id.offsetScale.x;
scale.y *= id.offsetScale.y;
rot = id.offsetRotation;
if (id.applyTransformRotation)
{
rot += id.transform.rotation.eulerAngles.z;
}
switch (id.type)
{
case LightingSpriteRenderer2D.Type.WhiteMask:
GL.Color(Color.white);
spriteRenderer.sprite = SpriteAtlasManager.RequestSprite(id.GetSprite(), SpriteRequest.Type.WhiteMask);
Max2D.DrawSpriteBatched_Tris_Day(spriteRenderer, offset.ToVector2() + position + id.offsetPosition, scale, rot, z);
break;
case LightingSpriteRenderer2D.Type.BlackMask:
GL.Color(Color.black);
spriteRenderer.sprite = SpriteAtlasManager.RequestSprite(id.GetSprite(), SpriteRequest.Type.WhiteMask);
Max2D.DrawSpriteBatched_Tris_Day(spriteRenderer, offset.ToVector2() + position + id.offsetPosition, scale, rot, z);
break;
}
LightingDebug.SpriteRenderersDrawn++;
}
GL.End();
}
static public void MaskSpriteWithAtlas(LightingBuffer2D buffer, LightingTilemapCollider2D id, Vector2D offset, float z)
{
if (id.maskType != LightingTilemapCollider2D.MaskType.Sprite)
{
return;
}
if (id.map == null)
{
return;
}
SetupLocation(buffer, id);
Sprite reqSprite;
PartiallyBatched_Tilemap batched;
for (int x = newPositionInt.x - sizeInt; x < newPositionInt.x + sizeInt; x++)
{
for (int y = newPositionInt.y - sizeInt; y < newPositionInt.y + sizeInt; y++)
{
if (x < 0 || y < 0)
{
continue;
}
if (x >= id.area.size.x || y >= id.area.size.y)
{
continue;
}
tile = id.map[x, y];
if (tile == null)
{
continue;
}
if (tile.GetOriginalSprite() == null)
{
continue;
}
polyOffset.x = x + tilemapOffset.x;
polyOffset.y = y + tilemapOffset.y;
polyOffset.x *= scale.x;
polyOffset.y *= scale.y;
polyOffset2.x = (float)polyOffset.x;
polyOffset2.y = (float)polyOffset.y;
if (LightingManager2D.culling && Vector2.Distance(polyOffset2, buffer.lightSource.transform.position) > 2 + buffer.lightSource.lightSize)
{
LightingDebug.culled++;
continue;
}
polyOffset.x += offset.x;
polyOffset.y += offset.y;
spriteRenderer.sprite = tile.GetAtlasSprite();
if (spriteRenderer.sprite == null)
{
reqSprite = SpriteAtlasManager.RequestSprite(tile.GetOriginalSprite(), SpriteRequest.Type.WhiteMask);
if (reqSprite == null)
{
// Add Partialy Batched
batched = new PartiallyBatched_Tilemap();
batched.virtualSpriteRenderer = new VirtualSpriteRenderer();
batched.virtualSpriteRenderer.sprite = tile.GetOriginalSprite();
batched.polyOffset = polyOffset.ToVector2();
batched.tileSize = tileSize;
buffer.partiallyBatchedList_Tilemap.Add(batched);
continue;
}
else
{
tile.SetAtlasSprite(reqSprite);
spriteRenderer.sprite = reqSprite;
}
}
polyOffset2.x = (float)polyOffset.x;
polyOffset2.y = (float)polyOffset.y;
Max2D.DrawSpriteBatched_Tris(spriteRenderer, buffer.lightSource.layerSetting[0], id.maskMode, polyOffset2, tileSize, 0, z);
LightingDebug.maskGenerations++;
}
}
}
public static void DrawWithAtlas(LightingBuffer2D buffer, int layer)
{
float lightSizeSquared = Mathf.Sqrt(buffer.lightSource.lightSize * buffer.lightSource.lightSize + buffer.lightSource.lightSize * buffer.lightSource.lightSize);
float z = buffer.transform.position.z;
offset.x = -buffer.lightSource.transform.position.x;
offset.y = -buffer.lightSource.transform.position.y;
manager = LightingManager2D.Get();
colliderList = LightingCollider2D.GetList();
LayerSetting layerSetting = buffer.lightSource.layerSetting[layer];
bool maskEffect = (layerSetting.effect == LightingLayerEffect.InvisibleBellow);
#if UNITY_2018_1_OR_NEWER
tilemapList = LightingTilemapCollider2D.GetList();
#endif
// Shadow Fill
manager.materials.GetAtlasMaterial().SetPass(0);
GL.Begin(GL.TRIANGLES);
if (drawShadows)
{
for (int id = 0; id < colliderList.Count; id++)
{
if ((int)colliderList[id].lightingCollisionLayer != layer)
{
continue;
}
// Collider Shadow
LightingBufferMesh.Shadow(buffer, colliderList[id], lightSizeSquared, z);
LightingBufferShape.Shadow(buffer, colliderList[id], lightSizeSquared, z, offset);
}
#if UNITY_2018_1_OR_NEWER
for (int id = 0; id < tilemapList.Count; id++)
{
if ((int)tilemapList[id].lightingCollisionLayer != layer)
{
continue;
}
// Tilemap Shadow
LightingBufferTilemapRectangle.Shadow(buffer, tilemapList[id], lightSizeSquared, z);
}
#endif
}
if (drawMask)
{
if (colliderList.Count > 0)
{
for (int id = 0; id < colliderList.Count; id++)
{
if ((int)colliderList[id].lightingMaskLayer != layer)
{
continue;
}
// Collider Shape Mask
LightingBufferShape.Mask(buffer, colliderList[id], layerSetting, offset, z);
// Collider Sprite Mask
LightingBufferSprite.MaskWithAtlas(buffer, colliderList[id], offset, z);
}
}
#if UNITY_2018_1_OR_NEWER
for (int id = 0; id < tilemapList.Count; id++)
{
if ((int)tilemapList[id].lightingMaskLayer != layer)
{
continue;
}
// Tilemap Shape Mask
LightingBufferTilemapRectangle.MaskShape(buffer, tilemapList[id], offset, z);
// Tilemap Sprite Mask
LightingBufferTilemapRectangle.MaskSpriteWithAtlas(buffer, tilemapList[id], offset, z);
}
#endif
}
GL.End();
// Partialy Batched (Default Edition)
if (buffer.partiallyBatchedList_Collider.Count > 0)
{
Material materialWhite = manager.materials.GetWhiteSprite();
Material materialBlack = manager.materials.GetBlackSprite();
Material material;
PartiallyBatched_Collider batch;
materialWhite.mainTexture = SpriteAtlasManager.Get().atlasTexture.texture;
materialWhite.SetPass(0);
for (int i = 0; i < buffer.partiallyBatchedList_Collider.Count; i++)
{
batch = buffer.partiallyBatchedList_Collider[i];
material = materialWhite;
if (maskEffect && colliderList[i].transform.position.y < buffer.lightSource.transform.position.y)
{
material = materialBlack;
}
LightingBufferSprite.MaskWithoutAtlas(buffer, batch.collider2D, material, offset, z);
}
materialWhite.mainTexture = null;
buffer.partiallyBatchedList_Collider.Clear();
}
if (buffer.partiallyBatchedList_Tilemap.Count > 0)
{
Material materialWhite = manager.materials.GetWhiteSprite();
Material materialBlack = manager.materials.GetBlackSprite();
PartiallyBatched_Tilemap batch;
Material material;
// Draw Each Partialy Batched
for (int i = 0; i < buffer.partiallyBatchedList_Tilemap.Count; i++)
{
batch = buffer.partiallyBatchedList_Tilemap[i];
material = materialWhite;
if (maskEffect && batch.polyOffset.y < 0)
{
material = materialBlack;
}
material.mainTexture = batch.virtualSpriteRenderer.sprite.texture;
Max2D.DrawSprite(material, batch.virtualSpriteRenderer, batch.polyOffset, batch.tileSize, 0, z);
material.mainTexture = null;
}
buffer.partiallyBatchedList_Tilemap.Clear();
}
}
public static void MaskWithAtlas(LightingBuffer2D buffer, LightingCollider2D id, Vector2D offset, float z)
{
if (id.shape.maskType == LightingCollider2D.MaskType.None)
{
return;
}
if (id.shape.maskType != LightingCollider2D.MaskType.Sprite)
{
return;
}
if (id.isVisibleForLight(buffer) == false)
{
return;
}
if (id.spriteRenderer == null)
{
return;
}
if (id.shape.GetOriginalSprite() == null)
{
return;
}
Sprite sprite = id.shape.GetAtlasSprite();
if (sprite == null)
{
Sprite reqSprite = SpriteAtlasManager.RequestSprite(id.shape.GetOriginalSprite(), SpriteRequest.Type.WhiteMask);
if (reqSprite == null)
{
PartiallyBatched_Collider batched = new PartiallyBatched_Collider();
batched.collider2D = id;
buffer.partiallyBatchedList_Collider.Add(batched);
return;
}
else
{
id.shape.SetAtlasSprite(reqSprite);
sprite = reqSprite;
}
}
Vector2 p = id.transform.position;
p.x += (float)offset.x;
p.y += (float)offset.y;
Vector2 scale = id.transform.lossyScale;
spriteRenderer.sprite = sprite;
Max2D.DrawSpriteBatched_Tris(spriteRenderer, buffer.lightSource.layerSetting[0], id.maskMode, p, scale, id.transform.rotation.eulerAngles.z, z);
LightingDebug.maskGenerations++;
}
