/**
* placeBGTile places only bg tiles in the center of current cell.
* @param position (Vector3) - The position in the cell where the sprite will be placed.
* The center of the sprite will be placed at this position.
* @param spriteToPlace (Sprite) - A sprite from a sliced sprite sheet.
* @param cellSize (float) - used to find the center of the cell.
**/
public void placeBGTile(Vector3 position, Sprite spriteToPlace)
{
placeTile(position, spriteToPlace);
type = CellType.Background;
tile.gameObject.layer = 0;
tile.GetComponent <SpriteRenderer>().sortingLayerID = SortingLayer.NameToID("Background");
}
/// <summary>
/// 初始化UI数据
/// 调用Lua初始化;
/// </summary>
/// <param name="uiName"></param>
/// <param name="go"></param>
private void InitUI(string uiName, GameObject go, object[] args)
{
go.transform.SetParent(UIRoot);
go.transform.ResetTransform();
RectTransform rt = go.transform.GetComponent <RectTransform>();
rt.anchorMin = Vector2.zero;
rt.anchorMax = Vector2.one;
rt.pivot = Vector2.one * 0.5f;
rt.offsetMin = Vector2.zero;
rt.offsetMax = Vector2.zero;
go.SetActive(true);
var canvas = go.GetComponent <Canvas>();
if (canvas != null)
{
orderIndex += orderInterval;
canvas.overrideSorting = true;
canvas.sortingLayerID = SortingLayer.NameToID("Default");
canvas.sortingOrder = orderIndex;
}
string luaViewName = UIViewUtils.GetLuaViewName(uiName);
PanelBridge.SetPanelData(go.GetInstanceID(), uiName, args);
PanelBridge panelBridge = go.AddComponent <PanelBridge>();
mPanelStack.Push(panelBridge);
}
public void Fire()
{
if (cannonTimer > 0.0f)
{
return;
}
cannonTimer = cannonCooldown;
if (health > 50)
{
_animator.Play("Base Layer.PlayerDefaultFiring");
}
else
{
_animator.Play("Base Layer.PlayerDamagedFiring");
}
if (sfxCannon)
{
_audioSource.clip = sfxCannon;
_audioSource.Play();
}
GameObject ball = Instantiate(GameObject.Find("Cannonball"), transform.position, Quaternion.identity);
ball.SetActive(true);
ball.GetComponent <Renderer>().sortingLayerID = SortingLayer.NameToID("Player");
ball.GetComponent <Renderer>().sortingOrder = 5;
ball.GetComponent <CannonGoBoomScript>().isActive = true;
ball.GetComponent <CannonGoBoomScript>().PlayerScript = this;
ball.GetComponent <CannonGoBoomScript>().SetStats(
true, 0.8f, 1f, 3f, 4.5f
);
ball.GetComponent <CannonGoBoomScript>().CurrentLane = _currentWave;
}
private void Awake()
{
if (_litForegroundLayer == -1)
{
_litForegroundLayer = SortingLayer.NameToID("Lit Foreground");
}
}
public void MakeBoundaryLines(float width, float height)
{
for (int i = 0; i < 4; i++)
{
GameObject go = new GameObject("line" + i.ToString());
LineRenderer li = go.AddComponent <LineRenderer>();
li.transform.SetParent(transform);
li.material = _whiteMat;
li.sortingLayerID = SortingLayer.NameToID("ON_GROUND");
li.startWidth = 0.02f;
li.endWidth = 0.02f;
_lineRenderers.Add(li);
}
DrawLine(_lineRenderers[0], new Vector3(transform.position.x, transform.position.y, -1),
new Vector3(transform.position.x + width / 2, transform.position.y + height / 2, -1));
DrawLine(_lineRenderers[1], new Vector3(transform.position.x + width / 2, transform.position.y + height / 2, -1),
new Vector3(transform.position.x, transform.position.y + height, -1));
DrawLine(_lineRenderers[2], new Vector3(transform.position.x, transform.position.y + height, -1),
new Vector3(transform.position.x - width / 2, transform.position.y + height / 2, -1));
DrawLine(_lineRenderers[3], new Vector3(transform.position.x - width / 2, transform.position.y + height / 2, -1),
new Vector3(transform.position.x, transform.position.y, -1));
}
//Code adapted from Nick Gravelyn's repo: https://github.com/nickgravelyn/UnityToolbag/tree/master/SortingLayer
private void DrawSortingLayers()
{
// Get the renderer from the target object
var renderer = (target as SpriteRenderer);
var sortingLayerNames = SortingLayer.layers.Select(l => l.name).ToArray();
// Look up the layer name using the current layer ID
string oldName = SortingLayer.IDToName(renderer.sortingLayerID);
// Use the name to look up our array index into the names list
int oldLayerIndex = System.Array.IndexOf(sortingLayerNames, oldName);
// Show the popup for the names
int newLayerIndex = EditorGUILayout.Popup("Sorting Layer", oldLayerIndex, sortingLayerNames);
// If the index changes, look up the ID for the new index to store as the new ID
if (newLayerIndex != oldLayerIndex)
{
Undo.RecordObject(renderer, "Edit Sorting Layer");
renderer.sortingLayerID = SortingLayer.NameToID(sortingLayerNames[newLayerIndex]);
EditorUtility.SetDirty(renderer);
}
// Expose the manual sorting order
int newSortingLayerOrder = EditorGUILayout.IntField("Order in Layer", renderer.sortingOrder);
if (newSortingLayerOrder != renderer.sortingOrder)
{
Undo.RecordObject(renderer, "Edit Sorting Order");
renderer.sortingOrder = newSortingLayerOrder;
EditorUtility.SetDirty(renderer);
}
}
public void ChangeSortingLayer(LayerType type)
{
for (int i = 0; i < part.Length; i++)
{
part[i].sortingLayerID = SortingLayer.NameToID(type.ToString());
}
}
public void AddWagon()
{
// new wagon for wagons1
GameObject newGO = (Instantiate(Resources.Load(wagonType))) as GameObject;
newGO.name = "train";
newGO.layer = SortingLayer.NameToID("Train");
//newGO.transform.localScale = new Vector3 (wagonSize.x,wagonSize.y,1);
//newGO.transform.parent = transform;
wagonXDimension = newGO.transform.GetComponent <SpriteRenderer>().sprite.bounds.size.x;
wagonScale = newGO.transform.localScale.x;
Vector3 newPos = wagonStartPos1 + new Vector3(0, 0, -0.5f);
newGO.transform.position = newPos;
newGO.transform.rotation = GetProperRotationToForwardVector(wagonStartPos2, wagonStartPos1);
wagons1.Add(newGO.GetComponent <Train>());
// new wagon for wagons2
GameObject newGO2 = (Instantiate(Resources.Load(wagonType))) as GameObject;
newGO2.name = "train";
//newGO2.transform.parent = transform;
//newGO2.transform.localScale = new Vector3 (wagonSize.x,wagonSize.y,1);
newPos = wagonStartPos2 + new Vector3(0, 0, -0.5f);
newGO2.transform.position = newPos;
newGO2.transform.rotation = GetProperRotationToForwardVector(wagonStartPos1, wagonStartPos2);
wagons2.Add(newGO2.GetComponent <Train>());
// reset the wagon positions
ResetWagonPositions();
}
private IEnumerator DoShock(float time)
{
Color col = fillSprite.color;
int layer = fillSprite.sortingLayerID;
int orderFill = fillSprite.sortingOrder;
int orderBorder = borderSprite.sortingOrder;
fillSprite.color = shockColor;
shadow.SetActive(false);
fillSprite.sortingLayerID = SortingLayer.NameToID(shockLayer);
borderSprite.sortingLayerID = SortingLayer.NameToID(shockLayer);
group.sortingLayerID = SortingLayer.NameToID(shockLayer);
fillSprite.sortingOrder = 1000;
borderSprite.sortingOrder = 1000;
skeleton.SetActive(true);
yield return(new WaitForSeconds(time));
fillSprite.color = col;
shadow.SetActive(true);
fillSprite.sortingLayerID = layer;
borderSprite.sortingLayerID = layer;
group.sortingLayerID = layer;
fillSprite.sortingOrder = orderFill;
borderSprite.sortingOrder = orderBorder;
skeleton.SetActive(false);
}
private void SortAll()
{
if (CanChangeAllRendererSortingOrder)
{
Renderer[] mrs = GetComponentsInChildren <Renderer>(true);
for (int i = 0; i < mrs.Length; i++)
{
Renderer mr = mrs[i];
mr.sortingLayerID = SortingLayer.NameToID(sortingLayer);
mr.sortingOrder = Order;
}
}
else if (CanChangeThisRendersoringOrder)
{
Renderer mr = GetComponent <Renderer>();
if (mr != null)
{
mr.sortingLayerID = SortingLayer.NameToID(sortingLayer);
mr.sortingOrder = Order;
}
}
if (CanChangeAllParticleSortingOrder)
{
ParticleSystem[] particles = GetComponentsInChildren <ParticleSystem>(true);
for (int i = 0; i < particles.Length; i++)
{
particles[i].GetComponent <Renderer>().sortingLayerID = SortingLayer.NameToID(sortingLayer);
particles[i].GetComponent <Renderer>().sortingOrder = Order;
}
}
else if (CanChangeThisParticleSortingOrder)
{
ParticleSystem particle = GetComponent <ParticleSystem>();
if (particle != null)
{
particle.GetComponent <Renderer>().sortingLayerID = SortingLayer.NameToID(sortingLayer);
particle.GetComponent <Renderer>().sortingOrder = Order;
}
}
if (CanChangeAllCanvasSortingOrder)
{
Canvas[] panels = GetComponentsInChildren <Canvas>(true);
for (int i = 0; i < panels.Length; i++)
{
panels[i].sortingLayerName = sortingLayer;
panels[i].sortingOrder = Order;
}
}
else if (CanChangeThisCanvasOrder)
{
Canvas panel = GetComponent <Canvas>();
if (panel != null)
{
panel.sortingLayerName = sortingLayer;
panel.sortingOrder = Order;
}
}
}
private void setUpGridNums()
{
gridNums = new GameObject[2][];
Vector3 size = new Vector3(0.5f, 0.5f);
int gridLayer = SortingLayer.NameToID("Grid");
TMP_FontAsset gridFont = Resources.Load("Fonts/RoundPixels SDF") as TMP_FontAsset;
for (int i = 0; i < 2; i++)
{
gridNums[i] = new GameObject[numGridLines];
for (int j = 0; j < numGridLines; j++)
{
int jIndex = j - originLineIndex;
GameObject temp = new GameObject(i + " " + jIndex);
TextMeshPro num = temp.AddComponent <TextMeshPro>();
num.sortingLayerID = gridLayer;
num.sortingOrder = -1;
num.text = jIndex.ToString();
num.color = Color.red;
num.alignment = TextAlignmentOptions.TopRight;
num.fontSize = 2;
num.rectTransform.sizeDelta = size;
num.font = gridFont;
temp.transform.SetParent(GridNumbersParent.transform);
gridNums[i][j] = temp;
}
}
}
void UpdateLayer()
{
var sr = GetComponent <ShapeRenderer>();
Assert.IsTrue(sr);
sr.SortingLayerID = SortingLayer.NameToID("UI");
}
private void EnsureInit()
{
if (registerTile != null)
{
return;
}
if (!isWindowedDoor)
{
closedLayer = LayerMask.NameToLayer("Door Closed");
}
else
{
closedLayer = LayerMask.NameToLayer("Windows");
}
spriteRenderer = GetComponentInChildren <SpriteRenderer>();
closedSortingLayer = SortingLayer.NameToID("Doors Closed");
openSortingLayer = SortingLayer.NameToID("Doors Open");
openLayer = LayerMask.NameToLayer("Door Open");
registerTile = gameObject.GetComponent <RegisterDoor>();
tileChangeManager = GetComponentInParent <TileChangeManager>();
hackingProcess = GetComponent <HackingProcessBase>();
isHackable = hackingProcess != null;
hackingLoaded = false;
}
public void OnHitBall(Ball ball)
{
Messenger.Broker.Publish(new OnRefrectBall());
ball.IsAlive = false;
subject.OnNext(Unit.Default);
var spriteRenderer = ball.GetComponent <SpriteRenderer>();
spriteRenderer.color = spriteRenderer.color / 1.5f;
spriteRenderer.sortingLayerID = SortingLayer.NameToID("ReflectedBall");
var s = ball.transform.localScale;
s.y /= 2f;
ball.transform.localScale = s;
Observable.Timer(anime1)
.TakeUntilDestroy(ball.gameObject)
.Subscribe(_ =>
{
Anime.PlayRelative(ball.transform.position, new Vector3(0f, 30f, 0f), Easing.OutExpo(TimeSpan.FromSeconds(3f)))
.TakeUntilDestroy(ball.gameObject)
.DoOnCompleted(() => Destroy(ball.gameObject))
.SubscribeToPosition(ball.transform);
Anime.PlayRelative(ball.transform.localScale, new Vector3(-0.3f, 10f, 0f), Easing.OutExpo(TimeSpan.FromSeconds(0.5f)))
.TakeUntilDestroy(ball.gameObject)
.SubscribeToLocalScale(ball.transform);
}).AddTo(ball);
}
public bool Initialize(string a_strName)
{
m_comGuiBinder = Utility.FindCompoent <ComGuiBinderBase>(gameObject, string.Empty);
m_canvas = Utility.FindCompoent <Canvas>(gameObject, string.Empty);
if (m_canvas == null)
{
m_canvas = gameObject.AddComponent <Canvas>();
}
m_canvas.overrideSorting = true;
m_canvas.sortingLayerID = SortingLayer.NameToID("Default");
m_canvas.sortingOrder = 0;
m_raycaster = Utility.FindCompoent <GraphicRaycaster>(gameObject, string.Empty);
if (m_raycaster == null)
{
m_raycaster = gameObject.AddComponent <GraphicRaycaster>();
}
m_arrGuiControls = gameObject.GetComponentsInChildren <GuiControl>();
for (int i = 0; i < m_arrGuiControls.Length; ++i)
{
m_arrGuiControls[i].Initialize();
}
m_guiEffectPlayer.Initialize(gameObject);
_SetVisible(false);
m_guiState = EGuiState.Closed;
m_strName = a_strName;
return(true);
}
public void initTopCard()
{
int topCardIndex = _cards.Count - 1;
_cards[topCardIndex].transform.position = transform.position + topCardIndex * _displacement;
_cards[topCardIndex].SetLayer(topCardIndex, SortingLayer.NameToID("Deck"));
}
IEnumerator playCardAnimation(CardStateAnimation cardStateAnimation, System.Action callBack)
{
float currentTime = 0;
Vector3 startPosition = cardStateAnimation.card.transform.position;
Vector3 endPosition = cardStateAnimation.Position;
cardStateAnimation.card.SetLayer(1, SortingLayer.NameToID("Animation"));
while (currentTime < _animationDuration)
{
float factor = currentTime / _animationDuration;
factor = _animationCurve.Evaluate(factor);
cardStateAnimation.card.transform.position = Vector3.Lerp(startPosition, endPosition, factor);
currentTime += Time.deltaTime;
yield return(null);
}
cardStateAnimation.card.transform.position = endPosition;
cardStateAnimation.card.SetLayer(cardStateAnimation.Layer, SortingLayer.NameToID("Deck"));
cardStateAnimation.card.setVisible(cardStateAnimation.isVisible);
cardStateAnimation.card.setFaceUp(cardStateAnimation.isFaceUp);
callBack();
}
public void ConvertSpriteRenderer_ConvertSortLayer_SameSortLayer(
[Values("Default", "AdditionalSortingLayer")] string sortingLayerName,
[Values(1, 20, 123)] int sortOrder)
{
var newSortingLayerAdded = EditorTestUtilities.AddSortingLayerToTagManager(sortingLayerName);
var sortingLayerId = SortingLayer.NameToID(sortingLayerName);
{
Root = new GameObject();
var spriteRenderer = CreateClassicComponent <SpriteRenderer>(Root);
spriteRenderer.sortingOrder = sortOrder;
spriteRenderer.sortingLayerID = sortingLayerId;
}
Assert.DoesNotThrow(() => { RunConversion(Root); });
using (var query = EntityManager.CreateEntityQuery(typeof(Unity.Tiny.Renderer2D)))
using (var renderers = query.ToComponentDataArray <Unity.Tiny.Renderer2D>(Allocator.TempJob))
{
var layer = renderers[0].SortingLayer;
var order = renderers[0].OrderInLayer;
Assert.That(layer, Is.EqualTo(SortingLayer.GetLayerValueFromID(sortingLayerId)));
Assert.That(order, Is.EqualTo(sortOrder));
}
if (newSortingLayerAdded)
{
EditorTestUtilities.RemoveSortingLayerFromTagManager(sortingLayerName);
}
}
public override void OnInspectorGUI()
{
EditorGUI.indentLevel = 0;
GUI.enabled = false;
EditorGUILayout.PropertyField(fontAsset_prop);
EditorGUILayout.PropertyField(spriteAsset_prop);
GUI.enabled = true;
EditorGUI.BeginChangeCheck();
// Look up the layer name using the current layer ID
string oldName = SortingLayer.IDToName(m_Renderer.sortingLayerID);
// Use the name to look up our array index into the names list
int oldLayerIndex = System.Array.IndexOf(m_SortingLayerNames, oldName);
// Show the pop-up for the names
int newLayerIndex = EditorGUILayout.Popup("Sorting Layer", oldLayerIndex, m_SortingLayerNames);
// If the index changes, look up the ID for the new index to store as the new ID
if (newLayerIndex != oldLayerIndex)
{
m_Renderer.sortingLayerID = SortingLayer.NameToID(m_SortingLayerNames[newLayerIndex]);
}
// Expose the manual sorting order
int newSortingLayerOrder = EditorGUILayout.IntField("Order in Layer", m_Renderer.sortingOrder);
if (newSortingLayerOrder != m_Renderer.sortingOrder)
{
m_Renderer.sortingOrder = newSortingLayerOrder;
}
}
//Avoid picking up ammo for player
void OnCollisionEnter2D(Collision2D collision)
{
if (collision.gameObject.GetComponent <Renderer>().sortingLayerID == SortingLayer.NameToID("Ammo"))
{
Physics2D.IgnoreCollision(collision.gameObject.GetComponent <Collider2D>(), GetComponent <Collider2D>());
}
}
void Awake()
{
Instance = this;
Application.targetFrameRate = 60;
SortLayerTopEffects = SortingLayer.NameToID("TopEffects");
LayerPlayer = LayerMask.NameToLayer("Player");
LayerEnemyProjectile = LayerMask.NameToLayer("EnemyProjectile");
LayerEnemyCorpse = LayerMask.NameToLayer("EnemyCorpse");
LayerPlayerProjectile = LayerMask.NameToLayer("PlayerProjectile");
LayerEnemy = LayerMask.NameToLayer("Enemy");
LayerNeutral = LayerMask.NameToLayer("Neutral");
LayerXpPill = LayerMask.NameToLayer("XpPill");
LayerOrc = LayerMask.NameToLayer("Orc");
SpriteFlashParamId = Shader.PropertyToID("_FlashAmount");
SpriteFlashColorParamId = Shader.PropertyToID("_FlashColor");
var bounds = GetComponent <BoxCollider2D>();
float halfX = bounds.size.x / 2;
float halfY = bounds.size.y / 2;
ArenaBounds = new Rect(-halfX, -halfY, halfX * 2, halfY * 2);
InitDeedItems();
TextFps.enabled = false;
}
// Start is called before the first frame update
void Awake()
{
success = GameObject.Find("Success");
successText = GameObject.Find("SuccessText").GetComponent <Text>();
success.SetActive(false);
gridPoint = new Vector3Int(0, 0, 0);
oldPoint = new Vector3Int(0, 0, 0);
mode = "Edit";
iterator = 0;
activeSpawners = new List <Vector2>();
// Instantiate Crosses
for (int i = -9; i <= 9; i++)
{
for (int j = -7; j <= 7; j++)
{
GameObject newCross = (GameObject)Instantiate(cross, new Vector3(i, j, -0.01f), Quaternion.identity);
newCross.transform.localScale.Set(0.2f, 0.2f, 0.2f);
newCross.GetComponent <Cross>().x = i;
newCross.GetComponent <Cross>().y = j;
newCross.GetComponent <Cross>().active = false;
newCross.layer = SortingLayer.NameToID("UI");
floor[i + 9, j + 7] = -1;
walls[i + 9, j + 7] = -1;
}
}
}
public void SetTileObjectBySprite(Sprite InSprite, float offset = 0.0f)
{
if (null == _curTileObject)
{
GameObject prefab = Resources.Load <GameObject>("Prefabs/TilePrefab");
_curTileObject = Instantiate(prefab);
_curTileObject.GetComponent <SpriteRenderer>().sprite = InSprite;
_curTileObject.GetComponent <SpriteRenderer>().sortingLayerID = SortingLayer.NameToID("GROUND");
_curTileObject.GetComponent <SpriteRenderer>().sortingOrder = _sortingOrder;
Vector3 pos = transform.position;
pos.y += 0.51f / 2; //grid height
pos.y += offset;
_curTileObject.transform.SetParent(transform);
_curTileObject.transform.position = pos;
_offset = offset;
}
else
{
_curTileObject.GetComponent <SpriteRenderer>().sprite = InSprite;
Vector3 pos = transform.position;
pos.y += 0.51f / 2;
_curTileObject.transform.position = pos;
_offset = 0.0f;
}
_spriteName = InSprite.name;
}
private void OnTriggerEnter2D(UnityEngine.Collider2D collision)
{
if (collision == plrCol)
{
spr = collision.GetComponent <SpriteRenderer>();
foreach (GameObject Furniture in List1)
{
Furniture.GetComponent <PolygonCollider2D>().enabled = false;
}
foreach (GameObject Furniture in List2)
{
Furniture.GetComponent <PolygonCollider2D>().enabled = true;
}
uprFlr.SetActive(true);
upFlrDOORS.SetActive(true);
grdFlr.enabled = false;
grdFlrEXTRA.enabled = false;
upFlrSPRITES.SetActive(true);
spr.sortingOrder = 1;
spr.sortingLayerID = SortingLayer.NameToID("1st Floor (items)");
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
var sortingLayerNames = SortingLayer.layers.Select(l => l.name).ToArray();
if (property.propertyType != SerializedPropertyType.Integer)
{
EditorGUI.HelpBox(position,
string.Format("{0} is not an integer but has [SortingLayer].", property.name),
MessageType.Error);
}
else
{
EditorGUI.BeginDisabledGroup(((SortingLayerAttribute)this.attribute).isReadOnly);
EditorGUI.BeginProperty(position, label, property);
// Look up the layer name using the current layer ID
string oldName = SortingLayer.IDToName(property.intValue);
// Use the name to look up our array index into the names list
int oldLayerIndex = Array.IndexOf(sortingLayerNames, oldName);
// Show the popup for the names
int newLayerIndex = EditorGUI.Popup(position, label.text, oldLayerIndex, sortingLayerNames);
// If the index changes, look up the ID for the new index to store as the new ID
if (newLayerIndex != oldLayerIndex)
{
property.intValue = SortingLayer.NameToID(sortingLayerNames[newLayerIndex]);
}
EditorGUI.EndProperty();
EditorGUI.EndDisabledGroup();
}
}
void OnCollisionExit(Collision col)
{
if (col.other.gameObject.layer == SortingLayer.NameToID("Floor"))
{
grounded = false;
}
}
/// <summary>
/// Creates a text value on top of the hexes
/// </summary>
/// <param name="textMessage"></param>
/// <param name="name"></param>
/// <param name="textWidth"></param>
/// <param name="textHeight"></param>
/// <param name="textX"></param>
/// <param name="textY"></param>
/// <param name="canvasInstance"></param>
public static void CreateHexText(string textMessage, string name, float textWidth, float textHeight, float textX, float textY, int fontSize, Color textColor, Canvas canvasInstance)
{
GameObject textGameObject = new GameObject(name);
textGameObject.layer = 12; // Set the layer so it renders above the hex but beneath the counters
textGameObject.transform.SetParent(canvasInstance.transform, false);
var tempText = textGameObject.AddComponent <TextMeshPro>();
tempText.text = textMessage;
if (textMessage.Length < 6)
{
tempText.fontSize = 120;
}
else if (textMessage.Length < 10)
{
tempText.fontSize = 106;
}
else
{
tempText.fontSize = 92;
}
tempText.renderer.sortingLayerID = SortingLayer.NameToID("Text");
tempText.rectTransform.anchoredPosition = new Vector2(textX, textY);
tempText.rectTransform.sizeDelta = new Vector2(textWidth, textHeight);
tempText.rectTransform.localScale = new Vector2(0.1f, 0.1f);
tempText.alignment = TMPro.TextAlignmentOptions.Center;
tempText.color = textColor;
tempText.raycastTarget = false;
}
public IEnumerator UnityConstantsTest()
{
var setting = new GenerateSetting()
{
Namespace = "UniEnumEditorTests",
OutputDir = "Assets/UniEnum.Tests/Editor/TestOutput",
};
AssetDatabase.DeleteAsset($"{setting.OutputDir}/TagValues.Generated.cs");
AssetDatabase.DeleteAsset($"{setting.OutputDir}/LayerValues.Generated.cs");
AssetDatabase.DeleteAsset($"{setting.OutputDir}/SortingLayerValues.Generated.cs");
UnityConstantValuesGenerator.UpdateUnityConstants(setting);
yield return(new RecompileScripts());
Assert.AreEqual("12@hoge -##A", TagName._12hogeA);
Assert.AreEqual(17, (int)LayerId.アイウエオ);
Assert.AreEqual((1 << 17), (int)LayerMaskValue.アイウエオ);
Assert.AreEqual(21, (int)LayerId._123abcWXZ11);
Assert.AreEqual((1 << 21), (int)LayerMaskValue._123abcWXZ11);
Assert.AreEqual(SortingLayer.NameToID("Default"), SortingLayerId.Default);
}
private void HandleSpriteLayerSelectionUI(Rect position, SerializedProperty property, GUIContent label, string[] spriteLayerNames)
{
EditorGUI.BeginProperty(position, label, property);
// To show which sprite layer is currently selected.
int currentSpriteLayerIndex;
bool layerFound = TryGetSpriteLayerIndexFromProperty(out currentSpriteLayerIndex, spriteLayerNames, property);
if (!layerFound)
{
// Set to default layer. (Previous layer was removed)
Debug.Log(string.Format(
"Property <color=brown>{0}</color> in object <color=brown>{1}</color> is set to the default layer. Reason: previously selected layer was removed.",
property.name, property.serializedObject.targetObject));
property.intValue = 0;
currentSpriteLayerIndex = 0;
}
int selectedSpriteLayerIndex = EditorGUI.Popup(position, label.text, currentSpriteLayerIndex, spriteLayerNames);
// Change property value if user selects a new sprite layer.
if (selectedSpriteLayerIndex != currentSpriteLayerIndex)
{
property.intValue = SortingLayer.NameToID(spriteLayerNames[selectedSpriteLayerIndex]);
}
EditorGUI.EndProperty();
}
private void Awake()
{
_line = gameObject.GetComponent <LineRenderer>();
_line.sortingLayerID = SortingLayer.NameToID(WireSortingLayer);
_line.sortingOrder = WireSortingIndex;
BuildWire();
}
