private void Awake()
{
if (!GetComponent <GraphicRaycaster>())
{
gameObject.AddComponent <GraphicRaycaster>();
}
barCanvas = GetComponent <Canvas>();
barCanvas.overrideSorting = true;
barCanvas.sortingLayerID = SortingLayer.NameToID("UI");
cancel.onClick.AddListener(Cancel);
}
protected override void InitializeView(GameEntity entity)
{
spriteRenderer.sortingLayerName = BubbleLayer;
shadow.sortingLayerName = BubbleLayer;
bubbleNumber.sortingLayerID = SortingLayer.NameToID(BubbleLayer);
shadow.sortingOrder = ShadowOrder;
spriteRenderer.sortingOrder = BubbleOrder;
bubbleNumber.sortingOrder = BubbleNumberOrder;
trail.enabled = false;
}
private void Awake()
{
animator = gameObject.GetComponent <Animator>();
registerTile = gameObject.GetComponent <RegisterDoor>();
closedLayer = LayerMask.NameToLayer("Door Closed");
closedSortingLayer = SortingLayer.NameToID("Doors Open");
openLayer = LayerMask.NameToLayer("Door Open");
openSortingLayer = SortingLayer.NameToID("Doors Closed");
SetLayer(openLayer, openSortingLayer);
}
private static int RaycastComparer(RaycastResult lhs, RaycastResult rhs)
{
if (lhs.module != rhs.module)
{
if (lhs.module.eventCamera != null && rhs.module.eventCamera != null && lhs.module.eventCamera.depth != rhs.module.eventCamera.depth)
{
// need to reverse the standard compareTo
if (lhs.module.eventCamera.depth < rhs.module.eventCamera.depth)
{
return(1);
}
if (lhs.module.eventCamera.depth == rhs.module.eventCamera.depth)
{
return(0);
}
return(-1);
}
if (lhs.module.sortOrderPriority != rhs.module.sortOrderPriority)
{
return(rhs.module.sortOrderPriority.CompareTo(lhs.module.sortOrderPriority));
}
if (lhs.module.renderOrderPriority != rhs.module.renderOrderPriority)
{
return(rhs.module.renderOrderPriority.CompareTo(lhs.module.renderOrderPriority));
}
}
if (lhs.sortingLayer != rhs.sortingLayer)
{
// Uses the layer value to properly compare the relative order of the layers.
var rid = SortingLayer.GetLayerValueFromID(rhs.sortingLayer);
var lid = SortingLayer.GetLayerValueFromID(lhs.sortingLayer);
return(rid.CompareTo(lid));
}
if (lhs.sortingOrder != rhs.sortingOrder)
{
return(rhs.sortingOrder.CompareTo(lhs.sortingOrder));
}
if (!Mathf.Approximately(lhs.distance, rhs.distance))
{
return(lhs.distance.CompareTo(rhs.distance));
}
if (lhs.depth != rhs.depth)
{
return(rhs.depth.CompareTo(lhs.depth));
}
return(lhs.index.CompareTo(rhs.index));
}
public void PassAboveUI(bool isEnabled)
{
if (isEnabled)
{
spriteRenderer.sortingLayerID = SortingLayer.NameToID("AboveUI");
}
else
{
spriteRenderer.sortingLayerID = SortingLayer.NameToID("Cell");
}
}
private void CreatePlayer(AvatarState avatarState)
{
_player = PlayerFactory.Create(avatarState).GetComponent <Player>();
_player.Set(avatarState);
_player.transform.SetParent(avatarPosition);
_player.transform.localPosition = Vector3.zero;
var orderInLayer = MainCanvas.instance.GetLayer(WidgetType).root.sortingOrder + 1;
_player.SetSortingLayer(SortingLayer.NameToID("UI"), orderInLayer);
}
public void AddObject(eTileLayer layer, MapObject mapObject)
{
List <MapObject> mapObjectList = _mapObjectMap[(int)layer];
int sortingID = SortingLayer.NameToID(layer.ToString());
int sortingOrder = mapObjectList.Count;
mapObject.SetSortingOrder(sortingID, sortingOrder);
mapObject.SetPosition(_position);
mapObjectList.Add(mapObject);
}
public void SetBKeyLabel(string label, Color c)
{
TextMeshPro tp = bkTextObj.GetComponent <TextMeshPro> ();
tp.sortingLayerID = SortingLayer.NameToID("MarkerText");
tp.sortingOrder = 2;
tp.SetText(label);
tp.color = c;
}
public virtual void SetSpriteLayer(bool anchoredLayer)
{
if (anchoredLayer)
{
spriteRenderer.sortingLayerID = SortingLayer.NameToID("Objects");
}
else
{
spriteRenderer.sortingLayerID = SortingLayer.NameToID("Items");
}
}
// Use this for initialization
void Start()
{
SortingLayerID = SortingLayer.GetLayerValueFromName("Default");
Renderer renderer = this.gameObject.GetComponent <Renderer>();
if (renderer != null)
{
renderer.sortingOrder = SortLayer;
renderer.sortingLayerID = SortingLayerID;
}
}
public void SetMarkerLabel(string label, Color c)
{
TextMeshPro tp = GetComponentInChildren <TextMeshPro> ();
tp.sortingLayerID = SortingLayer.NameToID("MarkerText");
tp.sortingOrder = 0;
tp.SetText(label);
tp.color = c;
}
private void Awake()
{
// Initialize animator and Register Door components
animator = gameObject.GetComponent <Animator>();
registerTile = gameObject.GetComponent <RegisterDoor>();
closedLayer = LayerMask.NameToLayer("Door Closed");
closedSortingLayer = SortingLayer.NameToID("Doors Open");
openLayer = LayerMask.NameToLayer("Door Open");
openSortingLayer = SortingLayer.NameToID("Doors Closed");
}
private static void Initialize()
{
if (s_IsInitialized)
{
return;
}
s_IsInitialized = true;
s_PlayerShots = SortingLayer.NameToID(nameof(PlayerShots));
s_EnemyShots = SortingLayer.NameToID(nameof(EnemyShots));
}
private SpriteRenderer CreateLineSpriteRenderer()
{
var lineObject = new GameObject();
lineObject.transform.parent = gameObject.transform;
var lineObjectSpriteRenderer = lineObject.AddComponent <SpriteRenderer>();
lineObjectSpriteRenderer.sprite = WhitePixel;
lineObjectSpriteRenderer.color = Color.blue;
lineObjectSpriteRenderer.sortingLayerID = SortingLayer.NameToID("TileHighlighting");
return(lineObjectSpriteRenderer);
}
private void Awake()
{
m_Animator = gameObject.GetComponentInChildren <Animator>();
m_Animator.SetFloat("Dir_x", m_Facing.x);
m_Animator.SetFloat("Dir_y", m_Facing.y);
m_Renderer = gameObject.GetComponentInChildren <SpriteRenderer>();
var sortingLayerId = SortingLayer.NameToID("OnGround");
Assert.IsFalse(sortingLayerId == 0, "Add sorting layer 'On Ground' to Tags and Layers. Sprite will not sort correctly without it.");
m_Renderer.sortingLayerID = sortingLayerId;
}
void Awake()
{
_levelData = GameManager.Instance.LevelData;
_moveCount = 0;
int count = _levelData.GetWaveCount();
_waveBar = GameManager.Instance.Definitions.HudWaveBar.GetComponentInChildren <SpriteSlider>();
SpriteRenderer r = _waveBar.renderer as SpriteRenderer;
Bounds waveBarBounds = r.bounds;
_waveBar.sliderValue = 0;
int actualMoves = 0;
GameObject waveTemplate = GameManager.Instance.Definitions.HudWave;
Vector3 pos = waveTemplate.transform.position;
Vector3 scale = waveTemplate.transform.localScale;
waveTemplate.SetActive(false);
_waves = new Wave[count];
for (int i = 0; i < count; i++)
{
GameObject go = (GameObject)Instantiate(waveTemplate);
_waves[i]._main = go;
go.SetActive(true);
go.name = "Wave" + i;
go.transform.parent = waveTemplate.transform.parent;
LevelData.WaveInfo wi = _levelData.GetWaveInfo(i);
actualMoves += wi._moves;
go.transform.position = new Vector3(-waveBarBounds.extents.x + waveBarBounds.extents.x * 2 * actualMoves / _levelData.GetTotalMoves(), pos.y, pos.z);
go.transform.localScale = scale;
ShadowLabel label = go.GetComponentInChildren <ShadowLabel>();
/*string str = "";
* for(int j = 0; j < wi._count; j++)
* str += "!";
* label.text = str;*/
label.text = "x" + wi._count.ToString();
_waves[i]._portrait = go.transform.FindChild("Portrait");
GameObject goEnemy = GameObject.Instantiate(_levelData.GetEnemyInfo(wi._enemyType)._prefab) as GameObject;
goEnemy.transform.parent = _waves[i]._portrait;
goEnemy.transform.localPosition = Vector3.zero;
goEnemy.transform.localRotation = Quaternion.identity;
SortingLayer.ForceLayerID(goEnemy, "HUDBack");
_waves[i]._enemy = goEnemy;
}
}
public void OnTargetSortingLayers(SerializedObject serializedObject, Object[] targets, GUIContent labelContent)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(labelContent);
GUIContent selectedLayers;
if (m_ApplyToSortingLayersList.Count == 1)
{
selectedLayers = new GUIContent(SortingLayer.IDToName(m_ApplyToSortingLayersList[0]));
}
else if (m_ApplyToSortingLayersList.Count == m_AllSortingLayers.Length)
{
selectedLayers = Styles.sortingLayerAll;
}
else if (m_ApplyToSortingLayersList.Count == 0)
{
selectedLayers = Styles.sortingLayerNone;
}
else
{
selectedLayers = Styles.sortingLayerMixed;
}
bool buttonDown = EditorGUILayout.DropdownButton(selectedLayers, FocusType.Keyboard, EditorStyles.popup);
if (Event.current.type == EventType.Repaint)
{
m_SortingLayerDropdownRect = GUILayoutUtility.GetLastRect();
}
if (buttonDown)
{
GenericMenu menu = new GenericMenu();
menu.allowDuplicateNames = true;
LayerSelectionData layerSelectionData = new LayerSelectionData(serializedObject, 0, targets);
menu.AddItem(Styles.sortingLayerNone, m_ApplyToSortingLayersList.Count == 0, OnNoSortingLayerSelected, layerSelectionData);
menu.AddItem(Styles.sortingLayerAll, m_ApplyToSortingLayersList.Count == m_AllSortingLayers.Length, OnAllSortingLayersSelected, layerSelectionData);
menu.AddSeparator("");
for (int i = 0; i < m_AllSortingLayers.Length; ++i)
{
var sortingLayer = m_AllSortingLayers[i];
layerSelectionData = new LayerSelectionData(serializedObject, sortingLayer.id, targets);
menu.AddItem(m_AllSortingLayerNames[i], m_ApplyToSortingLayersList.Contains(sortingLayer.id), OnSortingLayerSelected, layerSelectionData);
}
menu.DropDown(m_SortingLayerDropdownRect);
}
EditorGUILayout.EndHorizontal();
}
private void Awake()
{
collider2D = GetComponent <Collider2D>();
collider2D.enabled = false;
staticPos = transform.position;
index = transform.position.z;
if (sceneDragSortLayerId == 0)
{
sceneDragSortLayerId = SortingLayer.NameToID("DragedScene");
}
splitScenes.Add(this);
}
public void SyncSortingLayer()
{
if (false == EnableSyncLayer)
{
return;
}
if (InheritedLayer)
{
Canvas parentCanvas = this.GetComponentInParent <Canvas>();
OverrideSortingLayerId = null != parentCanvas ? parentCanvas.sortingLayerID : SortingLayer.NameToID("Default");
OverrideSortingLayerName = SortingLayer.IDToName(OverrideSortingLayerId);
}
int sortingOrderValue = SortingOrder;
if (SetSortingOrder && RelativeSortingOrder)
{
int baseSortingOrderValue = 0;
Canvas[] parentCanvas = this.GetComponentsInParent <Canvas>();
Canvas tempCanvas;
for (int i = 0, count = parentCanvas.Length; i < count; i++)
{
tempCanvas = parentCanvas[i];
if (tempCanvas.gameObject == this.gameObject)
{
continue;
}
if (false == tempCanvas.isRootCanvas && false == tempCanvas.overrideSorting)
{
continue;
}
if (false == tempCanvas.isRootCanvas && tempCanvas.sortingLayerID != OverrideSortingLayerId)
{
continue;
}
baseSortingOrderValue = tempCanvas.sortingOrder;
break;
}
sortingOrderValue = baseSortingOrderValue + SortingOrder;
}
if (false == SortingLayer.IsValid(OverrideSortingLayerId))
{
DYLogger.LogError("SyncSortingLayer fail, get unvalid sortinglayer " + OverrideSortingLayerName);
return;
}
Util.SetGameObjectSortingLayer(this.gameObject, OverrideSortingLayerId, IgnoreHigherLayer, SetSortingOrder, sortingOrderValue, RaycastTarget);
}
bool CompareOrder(SpriteRenderer renderer, TouchDownSubscriber subscriber)
{
int rendererLayerValue = SortingLayer.GetLayerValueFromID(renderer.sortingLayerID);
int subscriberLayerValue = subscriber.sortingLayerValue;
int layerCompare = rendererLayerValue.CompareTo(subscriberLayerValue);
if (layerCompare == 0)
{
return(renderer.sortingOrder.CompareTo(subscriber.sortingOrder) > 0);
}
return(layerCompare > 0);
}
public static int CompareTo(this SpriteRenderer self, SpriteRenderer other)
{
int selfLayer = SortingLayer.GetLayerValueFromID(self.sortingLayerID);
int otherLayer = SortingLayer.GetLayerValueFromID(other.sortingLayerID);
int layerCompare = selfLayer.CompareTo(otherLayer);
if (layerCompare == 0)
{
return(self.sortingOrder.CompareTo(other.sortingOrder));
}
return(layerCompare);
}
private void Awake()
{
pooledIndex = -1;
meshFilterOfVisualObject = GetComponent <MeshFilter>();
meshRenderer = GetComponent <MeshRenderer>();
material = meshRenderer.material;
meshRenderer.sortingLayerID = SortingLayer.NameToID("Ground");
meshRenderer.sortingOrder = sortingLayerSet;
AssignBasicMeshValue();
ImplementMeshValue();
}
private void Awake() {
itemMeshFilter = GetComponent<MeshFilter>();
itemMeshRenderer = GetComponent<MeshRenderer>();
itemMeshRenderer.sortingLayerID = SortingLayer.NameToID("Player");
itemMeshRenderer.sortingOrder = 20;
intervalTime = intervalTimeOrigin;
meshPosition = Vector3.zero;
AssignBasicQuadMeshValue();
UpdateQuad(meshPosition, 0, quadSize);
ImplementQuadMeshValue();
}
public void PassAboveUI(bool enabled)
{
isAboveUI = enabled;
if (enabled)
{
sortingGroup.sortingLayerID = SortingLayer.NameToID("AboveUI");
}
else
{
sortingGroup.sortingLayerID = SortingLayer.NameToID("Ball");
}
}
void Awake()
{
if (predictionType == predictionMode.Prediction2D)
{
rb2 = GetComponent <Rigidbody2D>();
}
else
{
rb = GetComponent <Rigidbody>();
}
lineSortingLayer = SortingLayer.NameToID(lineSortingLayerName);
}
/// <summary>
/// Subscribes to all connectors
/// </summary>
void Start()
{
m_initialPosition = transform.position;
m_rigidbody = GetComponent <Rigidbody2D>();
m_renderer = GetComponent <SpriteRenderer>();
m_pathRenderer = FindObjectOfType <PathRenderer>();
m_defaultLayer = m_renderer.sortingLayerID;
m_fallingLayer = SortingLayer.NameToID("PlayerFalling");
if (m_pathRenderer == null)
{
Debug.LogWarning("WARNING! Player is missing reference to path renderer");
}
}
//TileRenders are always Initialize-initialized.
protected void Initialize(ITransformHandler locationer, TiledRenderCfg cfg, Material material, bool is_static,
bool isPlayer)
{
locater = locationer;
parented = locater.HasParent();
isStatic = is_static;
material.enableInstancing = false; //Instancing doesn't work with this, and it has overhead, so disable it.
render.sharedMaterial = material;
render.sortingOrder = renderCounter++;
render.sortingLayerID = SortingLayer.NameToID(isPlayer ? cfg.playerSortingLayer : cfg.sortingLayer);
DontUpdateTimeAfter = cfg.dontUpdateTimeAfter;
//mr.GetPropertyBlock(pb);
}
void Awake()
{
sprite = GetComponent <SpriteRenderer>();
if (!SpritePivotAlignment.GetSpriteAlignment(gameObject).Equals(SpriteAlignment.TopRight))
{
Debug.LogError("You forgot change the sprite pivot to Top Right.");
}
Vector2 spriteSize_wu = new Vector2(sprite.bounds.size.x / transform.localScale.x, sprite.bounds.size.y / transform.localScale.y);
Vector3 scale = new Vector3(1.0f, 1.0f, 1.0f);
if (0.0f != gridX)
{
float width_wu = sprite.bounds.size.x / gridX;
scale.x = width_wu / spriteSize_wu.x;
spriteSize_wu.x = width_wu;
}
if (0.0f != gridY)
{
float height_wu = sprite.bounds.size.y / gridY;
scale.y = height_wu / spriteSize_wu.y;
spriteSize_wu.y = height_wu;
}
GameObject childPrefab = new GameObject();
SpriteRenderer childSprite = childPrefab.AddComponent <SpriteRenderer>();
childPrefab.transform.position = transform.position;
childSprite.sprite = sprite.sprite;
childSprite.sortingLayerID = SortingLayer.NameToID("Background");
childSprite.sortingOrder = 5;
GameObject child;
for (int i = 0, h = (int)Mathf.Round(sprite.bounds.size.y); i *spriteSize_wu.y < h; i++)
{
for (int j = 0, w = (int)Mathf.Round(sprite.bounds.size.x); j *spriteSize_wu.x < w; j++)
{
child = Instantiate(childPrefab) as GameObject;
child.transform.position = transform.position - (new Vector3(spriteSize_wu.x * j, spriteSize_wu.y * i, 0));
child.transform.localScale = scale;
child.transform.parent = transform;
}
}
Destroy(childPrefab);
sprite.enabled = false; // Disable this SpriteRenderer and let the prefab children render themselves
}
protected virtual void Update()
{
if (_isInAir)
{
if (_afterThrowCounter > 0)
{
_afterThrowCounter -= Time.deltaTime;
}
// If we've been in the air long enough, need to check if it's time to consider ourself "on the ground"
else if (_body.velocity.magnitude <= onGroundThreshold)
{
_body.velocity = Vector2.zero;
if (_afterThrowCounter <= 0 && _tileThatThrewUs != null && _tileThatThrewUs.GetComponent <Collider2D>() != null)
{
Physics2D.IgnoreCollision(_tileThatThrewUs.GetComponent <Collider2D>(), _collider, false);
}
_body.collisionDetectionMode = CollisionDetectionMode2D.Discrete;
_collider.isTrigger = true;
addTag(TileTags.CanBeHeld);
_isInAir = false;
print("landed");
}
}
if (!_isInAir && has_been_thrown)
{
print("spawning hole");
GameObject room = transform.parent.gameObject;
Vector2 grid_c = toGridCoord(localX, localY);
Tile new_hole = spawnTile(sand_prefab, room.transform, (int)grid_c.x, (int)grid_c.y);
//new_hole.transform.SetPositionAndRotation(new Vector3(transform.position.x, transform.position.y, 0), Quaternion.identity);
new_hole.sprite.sortingLayerID = SortingLayer.NameToID("Floor");
die();
}
if (_tileHoldingUs != null)
{
// We aim the rock behind us.
_sprite.transform.localPosition = new Vector3(-0.5f, 0, 0);
float aimAngle = Mathf.Atan2(_tileHoldingUs.aimDirection.y, _tileHoldingUs.aimDirection.x) * Mathf.Rad2Deg;
transform.localRotation = Quaternion.Euler(0, 0, aimAngle);
}
else
{
_sprite.transform.localPosition = Vector3.zero;
}
updateSpriteSorting();
}
/// <summary>
/// return 1 means lhs > rhs, so lhs will be AFTER rhs
/// DESCENT order by depth/sortOrderPriority/sortingLayer/sortingOrder/depth/distance
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <returns></returns>
private static int RaycastComparer(RaycastResult lhs, RaycastResult rhs)
{
if (lhs.module != rhs.module)
{
if (lhs.module.eventCamera != null && rhs.module.eventCamera != null &&
lhs.module.eventCamera.depth != rhs.module.eventCamera.depth)
{
/*
* if (lhs.module.eventCamera.depth < rhs.module.eventCamera.depth)
* return 1;
* if (lhs.module.eventCamera.depth == rhs.module.eventCamera.depth)
* return 0;
* return -1;
*/
// descent order with depth
return(rhs.module.eventCamera.depth.CompareTo(lhs.module.eventCamera.depth));
}
if (lhs.module.sortOrderPriority != rhs.module.sortOrderPriority)
{
return(rhs.module.sortOrderPriority.CompareTo(lhs.module.sortOrderPriority));
}
if (lhs.module.renderOrderPriority != rhs.module.renderOrderPriority)
{
return(rhs.module.renderOrderPriority.CompareTo(lhs.module.renderOrderPriority));
}
}
if (lhs.sortingLayer != rhs.sortingLayer)
{
var rid = SortingLayer.GetLayerValueFromID(rhs.sortingLayer);
var lid = SortingLayer.GetLayerValueFromID(lhs.sortingLayer);
return(rid.CompareTo(lid));
}
if (lhs.sortingOrder != rhs.sortingOrder)
{
return(rhs.sortingOrder.CompareTo(lhs.sortingOrder));
}
if (lhs.depth != rhs.depth)
{
return(rhs.depth.CompareTo(lhs.depth));
}
if (lhs.distance != rhs.distance)
{
return(rhs.distance.CompareTo(lhs.distance));
}
return(lhs.index.CompareTo(rhs.index));
}
public void SetSortingLayer(SortingLayer layer)
{
SetSortingLayerName(transform, layers[(int)layer].sortingLayerName);
Vector3 pos = transform.localPosition;
pos.z = layers[(int)layer].zValue;
transform.localPosition = pos;
}
public void SortAllDeepFrom(SortingLayer sortingLayer)
{
SetDeepStaticOrder(gameObject, sortingLayer.SortingLayerId);
SetDeepDeltaOrder(gameObject, sortingLayer.SortingOrder);
}
