// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void AddDirtyLayer( exLayer _layer )
{
if ( _layer.type == exLayer.Type.Normal ) {
updateAll = true;
}
else {
dirtyLayers.Add (_layer);
_layer.isDirty = true;
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void Init( exLayer _layer )
{
initArrows = new Arrow[size];
if ( prefab != null ) {
for ( int i = 0; i < size; ++i ) {
GameObject obj = GameObject.Instantiate(prefab, Vector3.zero, Quaternion.identity) as GameObject;
initArrows[i] = obj.GetComponent<Arrow>();
if (obj.GetComponent<exLayer>()) {
obj.GetComponent<exLayer>().parent = _layer;
} else {
Debug.LogError ("please add a layer component to arrow prefab.");
}
}
}
Reset();
}
// DISABLE: this will help update layer in scene, but cause a lot {
// // ------------------------------------------------------------------
// // Desc:
// // ------------------------------------------------------------------
// void Update () {
// SceneView.RepaintAll();
// }
// } DISABLE end
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void AddSelected( exLayer _l )
{
if ( _l == null )
return;
if ( selectedLayers.IndexOf(_l) == -1 ) {
selectedLayers.Add(_l);
foreach ( exLayer l in _l.children ) {
AddSelected (l);
}
}
sortSelection = true;
List<GameObject> goList = new List<GameObject>();
foreach ( exLayer layer in selectedLayers ) {
goList.Add(layer.gameObject);
}
Selection.objects = goList.ToArray();
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
int AddLayerRecursively(exLayer _curLayer,
bool _doCount,
ref float _totalDepth,
ref List <exLayer> _layerList)
{
int count = 1;
bool doCount = _doCount;
//
_curLayer.isDirty = true;
_layerList.Add(_curLayer);
//
if (_curLayer.type != exLayer.Type.Normal)
{
doCount = false;
if (_curLayer.type == exLayer.Type.Dynamic)
{
_totalDepth -= _curLayer.range;
}
}
//
foreach (exLayer childLayer in _curLayer.children)
{
childLayer.indentLevel = _curLayer.indentLevel + 1;
count += AddLayerRecursively(childLayer, doCount, ref _totalDepth, ref _layerList);
}
if (doCount == false)
{
return(1);
}
return(count);
}
///////////////////////////////////////////////////////////////////////////////
// static
///////////////////////////////////////////////////////////////////////////////
public static int CompareByIndentLevel ( exLayer _a, exLayer _b ) {
return _a.indentLevel - _b.indentLevel;
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void OnGUI()
{
EditorGUI.indentLevel = 0;
// ========================================================
// check if selection valid
// ========================================================
//
if (curEditGO == null)
{
GUILayout.Space(10);
GUILayout.Label("Please select a GameObject for editing");
return;
}
//
if (curEditGO.GetComponent <Camera>())
{
curLayer = curEditGO.GetComponent <exLayerMng>();
if (curLayer == null)
{
if (GUILayout.Button("Add Layer Manager", GUILayout.Width(200)))
{
curLayer = curEditGO.AddComponent <exLayerMng> ();
}
}
}
else
{
//
curLayer = curEditGO.GetComponent <exLayer>();
if (curLayer == null)
{
GUILayout.Space(10);
GUILayout.Label("There is no edit layer in this GameObject");
return;
}
}
//
if (curLayer == null)
{
GUILayout.Label("Invalid GameObject");
return;
}
// ========================================================
// toolbar
// ========================================================
GUILayout.BeginHorizontal(EditorStyles.toolbar);
// ========================================================
// update button
// ========================================================
GUILayout.FlexibleSpace();
exLayerMng layerMng = curLayer as exLayerMng;
GUI.enabled = (layerMng != null);
if (GUILayout.Button("Update", EditorStyles.toolbarButton))
{
layerMng.AddDirtyLayer(layerMng);
EditorUtility.SetDirty(layerMng);
}
GUI.enabled = true;
GUILayout.Space(5);
// ========================================================
// lock button
// ========================================================
lockSelection = GUILayout.Toggle(lockSelection, "Lock", EditorStyles.toolbarButton);
GUILayout.EndHorizontal();
// ========================================================
// scroll view
// ========================================================
float toolbarHeight = EditorStyles.toolbar.CalcHeight(new GUIContent(""), 0);
scrollPos = EditorGUILayout.BeginScrollView(scrollPos,
GUILayout.Width(position.width),
GUILayout.Height(position.height - toolbarHeight));
GUILayout.Space(10);
// ========================================================
// draw the tree
// ========================================================
//
float space = 5.0f;
Rect lastRect = GUILayoutUtility.GetLastRect();
LayerTreeField(space, lastRect.yMax, curLayer);
GUILayout.Space(5);
// ========================================================
// Clear All Layer Button
// ========================================================
Color oldBGColor = GUI.backgroundColor;
Color oldCTColor = GUI.contentColor;
GUI.backgroundColor = Color.red;
GUI.contentColor = Color.yellow;
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Remove All Layers", GUILayout.Width(120)))
{
bool doRemove = EditorUtility.DisplayDialog("Warning!",
"This operation will remove all exLayer Component in the editor, do you want to continue operation",
"Yes", "No");
if (doRemove)
{
RecursivelyDestroyLayer(curLayer);
}
}
GUILayout.EndHorizontal();
GUI.backgroundColor = oldBGColor;
GUI.contentColor = oldCTColor;
// ========================================================
// process mouse event
Event e = Event.current;
// ========================================================
if (e.type == EventType.MouseDown && e.button == 0 && e.clickCount == 1)
{
selectedLayers.Clear();
e.Use();
Repaint();
}
else if (e.type == EventType.MouseUp)
{
inDragState = false;
e.Use();
Repaint();
}
// do add GameObject to layerMng
else if (e.type == EventType.DragUpdated)
{
// Show a copy icon on the drag
foreach (Object o in DragAndDrop.objectReferences)
{
if (o is GameObject)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
break;
}
}
}
else if (e.type == EventType.DragPerform)
{
DragAndDrop.AcceptDrag();
try {
EditorUtility.DisplayProgressBar("Add new layer items", "Add new layer itmes...", 0.5f);
//
Object oldSelActiveObject = null;
List <Object> oldSelObjects = new List <Object>();
foreach (Object o in Selection.objects)
{
oldSelObjects.Add(o);
}
oldSelActiveObject = Selection.activeObject;
//
List <exLayer> addedLayers = new List <exLayer>();
List <exLayer> newLayers = new List <exLayer>();
foreach (Object o in DragAndDrop.objectReferences)
{
// never add self, it cause dead loop
if (o == curEditGO)
{
continue;
}
//
Selection.activeObject = o;
Object[] objects = Selection.GetFiltered(typeof(GameObject), SelectionMode.Deep);
foreach (Object obj in objects)
{
if (obj)
{
GameObject go = obj as GameObject;
exLayer layer = go.GetComponent <exLayer>();
if (layer == null)
{
layer = go.AddComponent <exLayer>();
newLayers.Add(layer);
}
if (addedLayers.IndexOf(layer) == -1)
{
addedLayers.Add(layer);
}
}
}
}
// sync new layer's parent
foreach (exLayer layer in newLayers)
{
Transform parent = layer.transform.parent;
while (parent != null)
{
exLayer parentLayer = parent.GetComponent <exLayer>();
if (parentLayer)
{
layer.parent = parentLayer;
break;
}
parent = parent.parent;
}
}
//
List <exLayer> parentOfNewLayers = new List <exLayer>();
foreach (exLayer li in addedLayers)
{
if (addedLayers.IndexOf(li.parent) == -1)
{
parentOfNewLayers.Add(li);
}
}
foreach (exLayer li in parentOfNewLayers)
{
if (li.parent != null)
{
EditorUtility.SetDirty(li.parent);
}
li.ForceSetParent(curLayer);
EditorUtility.SetDirty(li);
}
EditorUtility.SetDirty(curLayer);
//
Selection.objects = oldSelObjects.ToArray();
Selection.activeObject = oldSelActiveObject;
EditorUtility.ClearProgressBar();
}
catch (System.Exception) {
EditorUtility.ClearProgressBar();
throw;
}
Repaint();
}
EditorGUILayout.EndScrollView();
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
int AddLayerRecursively ( exLayer _curLayer,
bool _doCount,
ref float _totalDepth,
ref List<exLayer> _layerList ) {
int count = 1;
bool doCount = _doCount;
//
_curLayer.isDirty = true;
_layerList.Add ( _curLayer );
//
if ( _curLayer.type != exLayer.Type.Normal ) {
doCount = false;
if ( _curLayer.type == exLayer.Type.Dynamic ) {
_totalDepth -= _curLayer.range;
}
}
//
foreach ( exLayer childLayer in _curLayer.children ) {
childLayer.indentLevel = _curLayer.indentLevel + 1;
count += AddLayerRecursively ( childLayer, doCount, ref _totalDepth, ref _layerList );
}
if ( doCount == false )
return 1;
return count;
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
List<exLayer> CalculateDepthForDynamicLayer ( exLayer _curLayer ) {
float totalDepth = 0.0f;
List<exLayer> layerList = new List<exLayer>();
AddLayerRecursively ( _curLayer, true, ref totalDepth, ref layerList );
if ( layerList.Count > 1 ) {
float unitLayer = (float)_curLayer.range/(float)(layerList.Count-1);
float curDepth = _curLayer.depth;
for ( int i = 0; i < layerList.Count; ++i ) {
exLayer layer = layerList[i];
layer.depth = curDepth;
layer.isDirty = true;
if ( layer.type == exLayer.Type.Normal ) {
curDepth += unitLayer;
}
}
}
return layerList;
}
// ------------------------------------------------------------------
/// \param _index insert layer before the index of the children
/// \param _layer the layer to insert
///
/// Insert the _layer at the given _index of the children
// ------------------------------------------------------------------
public void InsertAt( int _index, exLayer _layer )
{
if ( _layer.parent == this ) {
int index = children_.IndexOf (_layer);
if ( index > _index ) {
_layer.parent = null;
children_.Insert ( _index, _layer );
_layer.parent_ = this;
}
else {
children_.Insert ( _index, _layer );
_layer.parent = null;
_layer.parent_ = this;
}
}
else {
_layer.parent = null;
children_.Insert ( _index, _layer );
_layer.parent_ = this;
}
}
///////////////////////////////////////////////////////////////////////////////
// Public Functions
///////////////////////////////////////////////////////////////////////////////
// ------------------------------------------------------------------
/// Create a new GameObject contains an exMesh component
// ------------------------------------------------------------------
public static exMesh Create(exLayer _layer)
{
#if UNITY_EDITOR
GameObject go = UnityEditor.EditorUtility.CreateGameObjectWithHideFlags("", exReleaseFlags.hideAndDontSave | exReleaseFlags.notEditable);
#else
GameObject go = new GameObject();
// 当在EX_DEBUG模式下，如果显示着GO的Inspector，再启动游戏，由于GO是DontSave的，会先被销毁。这时Unity将会报错，但不影响运行，这个问题在类似插件中也会存在。
go.hideFlags = exReleaseFlags.hideAndDontSave | exReleaseFlags.notEditable;
#endif
exMesh res = go.AddComponent<exMesh>();
res.UpdateDebugName(_layer);
res.Init();
return res;
}
///////////////////////////////////////////////////////////////////////////////
// static
///////////////////////////////////////////////////////////////////////////////
public static int CompareByIndentLevel(exLayer _a, exLayer _b)
{
return(_a.indentLevel - _b.indentLevel);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void LayerTreeField(float _x, float _y, exLayer _layer)
{
//
layers.Clear();
Rect layerFieldRect = new Rect(_x, _y, position.width - 2.0f * _x, layerFieldHeight);
// DISABLE {
// float totalLayerHeight = LayerField ( layerFieldRect, 0, _layer );
// GUILayoutUtility.GetRect ( layerFieldRect.width, totalLayerHeight );
LayerField(layerFieldRect, 0, _layer);
// } DISABLE end
// ========================================================
// process drag
// ========================================================
if (inDragState && layerCursorIn != null)
{
bool insertLayerSelected = selectedLayers.IndexOf(layerCursorIn) != -1;
int index = 0;
index = layers.IndexOf(layerCursorIn);
Rect rect = new Rect(_x,
_y + index * (layerFieldHeight) - index,
position.width - 2.0f * _x,
layerFieldHeight);
int hlIndex = -1;
//
if (Event.current.mousePosition.y <= rect.y + rect.height * 0.5f)
{
index = layers.IndexOf(layerCursorIn);
exLayer prevLayer = (index - 1 < 0) ? null : layers[index - 1];
// up
if (prevLayer != null &&
(selectedLayers.IndexOf(prevLayer) == -1 ||
insertLayerSelected == false))
{
hlIndex = index - 1;
exEditorHelper.DrawRect(new Rect(rect.x, rect.y + 1 - rect.height * 0.1f, rect.width, rect.height * 0.2f),
new Color(1.0f, 1.0f, 0.0f, 1.0f),
new Color(1.0f, 1.0f, 0.0f, 1.0f));
}
}
else if (Event.current.mousePosition.y > rect.y + rect.height * 0.5f)
{
index = layers.IndexOf(layerCursorIn);
exLayer nextLayer = (index > layers.Count - 1) ? null : layers[index];
int nextIndexInSelection = selectedLayers.IndexOf(nextLayer);
// down
if (nextLayer != null &&
(nextIndexInSelection == -1 ||
nextIndexInSelection == selectedLayers.Count - 1 ||
insertLayerSelected == false))
{
hlIndex = index;
exEditorHelper.DrawRect(new Rect(rect.x, rect.y + rect.height * 0.9f, rect.width, rect.height * 0.2f),
new Color(1.0f, 1.0f, 0.0f, 1.0f),
new Color(1.0f, 1.0f, 0.0f, 1.0f));
}
}
//
exLayer hlLayer = null;
exLayer insertLayer = null;
exLayer insertLayerNext = null;
// highlight the layer for insert
if (hlIndex != -1)
{
insertLayer = layers[hlIndex];
insertLayerNext = (hlIndex == layers.Count - 1) ? null : layers[hlIndex + 1];
hlLayer = layers[hlIndex];
float indentX = _x + hlLayer.indentLevel * 15.0f + 10.0f;
if (hlLayer.children.Count == 0)
{
indentX += 15.0f;
}
while (selectedLayers.IndexOf(hlLayer) != -1 || Event.current.mousePosition.x <= indentX)
{
exLayer hlParent = hlLayer.parent;
if (hlParent == null)
{
break;
}
if (insertLayerNext != null &&
(insertLayerNext.indentLevel - hlParent.indentLevel) >= 2)
{
break;
}
//
hlLayer = hlParent;
indentX = _x + hlLayer.indentLevel * 15.0f + 10.0f;
if (hlLayer.children.Count == 0)
{
indentX += 15.0f;
}
}
hlIndex = layers.IndexOf(hlLayer);
}
// again
if (hlIndex != -1)
{
exEditorHelper.DrawRect(new Rect(_x,
_y + hlIndex * (layerFieldHeight) - hlIndex,
position.width - 2.0f * _x,
layerFieldHeight),
new Color(0.0f, 1.0f, 0.0f, 0.2f),
new Color(0.0f, 0.0f, 0.0f, 0.0f));
}
//
if ((Event.current.type == EventType.MouseUp && Event.current.button == 0) ||
(Event.current.type == EventType.KeyDown && Event.current.keyCode == KeyCode.Escape))
{
inDragState = false;
if (hlIndex != -1 && Event.current.type == EventType.MouseUp)
{
//
if (sortSelection)
{
SortSelection();
sortSelection = false;
}
List <exLayer> insertList = new List <exLayer>();
foreach (exLayer layer in selectedLayers)
{
if (selectedLayers.IndexOf(layer.parent) == -1)
{
insertList.Add(layer);
}
}
// get exact insert layer
while ((insertLayer.indentLevel - hlLayer.indentLevel) > 1)
{
insertLayer = insertLayer.parent;
}
if (hlLayer.children.Count == 0)
{
foreach (exLayer layer in insertList)
{
if (layer.parent != null)
{
EditorUtility.SetDirty(layer.parent);
}
layer.parent = hlLayer;
EditorUtility.SetDirty(layer);
}
}
else
{
for (int i = insertList.Count - 1; i >= 0; --i)
{
int insertIdx = hlLayer.children.IndexOf(insertLayer) + 1;
if (insertList[i].parent != null)
{
EditorUtility.SetDirty(insertList[i].parent);
}
hlLayer.InsertAt(insertIdx, insertList[i]);
EditorUtility.SetDirty(insertList[i]);
}
}
EditorUtility.SetDirty(hlLayer);
}
//
EditorUtility.SetDirty(curLayer);
Event.current.Use();
Repaint();
}
}
// ========================================================
// do shift select
// ========================================================
if (doShiftSelect)
{
doShiftSelect = false;
//
int idx1 = layers.IndexOf(shiftClickStart);
int idx2 = layers.IndexOf(lastShiftClick);
if (idx1 != -1 && idx2 != -1)
{
if (idx1 > idx2)
{
int tmp = idx1;
idx1 = idx2;
idx2 = tmp;
}
for (int i = idx1; i <= idx2; ++i)
{
RemoveSelected(layers[i]);
}
}
//
idx1 = layers.IndexOf(shiftClickStart);
idx2 = layers.IndexOf(curShiftClick);
if (idx1 != -1 && idx2 != -1)
{
if (idx1 > idx2)
{
int tmp = idx1;
idx1 = idx2;
idx2 = tmp;
}
for (int i = idx1; i <= idx2; ++i)
{
AddSelected(layers[i]);
}
}
}
// ========================================================
// process delete
// ========================================================
if (Event.current.type == EventType.KeyDown &&
(Event.current.keyCode == KeyCode.Delete ||
Event.current.keyCode == KeyCode.Backspace))
{
List <exLayer> deleteList = new List <exLayer>();
foreach (exLayer layer in selectedLayers)
{
if (selectedLayers.IndexOf(layer.parent) == -1)
{
deleteList.Add(layer);
}
}
selectedLayers.Clear();
foreach (exLayer layer in deleteList)
{
layer.parent = null;
EditorUtility.SetDirty(layer);
}
//
EditorUtility.SetDirty(curLayer);
Event.current.Use();
Repaint();
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void CalculateDepthForAbstractLayer( exLayer _curLayer, bool _doAssign )
{
float totalDepth = 0.0f;
List<exLayer> layerList = new List<exLayer>();
AddLayerRecursively ( _curLayer, true, ref totalDepth, ref layerList );
float curDepth = _curLayer.depth;
for ( int i = 0; i < layerList.Count; ++i ) {
exLayer layer = layerList[i];
layer.depth = curDepth;
layer.isDirty = true;
}
// assignment
if ( _doAssign ) {
for ( int i = 0; i < layerList.Count; ++i ) {
exLayer layer = layerList[i];
if ( layer.isDirty == false )
continue;
RecursivelyUpdateLayer ( layer.transform.root );
}
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
float LayerField(Rect _rect, int _indentLevel, exLayer _layer)
{
if (_layer == null)
{
return(_rect.y);
}
// get selected
bool selected = selectedLayers.IndexOf(_layer) != -1;
// ========================================================
// draw field
// ========================================================
// draw rect
exEditorHelper.DrawRect(_rect,
selected ? new Color(0.0f, 0.4f, 0.8f, 1.0f) : new Color(0.25f, 0.25f, 0.25f, 1.0f),
new Color(0.0f, 0.0f, 0.0f, 1.0f));
float curX = _rect.x;
float curY = _rect.y;
GUI.BeginGroup(_rect);
// draw foldout
curX += _indentLevel * 15.0f + 10.0f;
if (_layer.children.Count > 0)
{
_layer.foldout = EditorGUI.Foldout(new Rect(curX, 2, 20, _rect.height - 2), _layer.foldout, "");
}
curX += 20;
_layer.indentLevel = _indentLevel;
// draw label
GUI.Label(new Rect(curX, 1, _rect.width - curX, _rect.height - 2), _layer.name);
// draw enum
EditorGUIUtility.LookLikeInspector();
Color oldColor = GUI.contentColor;
Color oldBGColor = GUI.backgroundColor;
switch (_layer.type)
{
case exLayer.Type.Dynamic:
GUI.backgroundColor = Color.green;
GUI.contentColor = Color.green;
break;
case exLayer.Type.Abstract:
GUI.backgroundColor = Color.yellow;
GUI.contentColor = Color.yellow;
break;
}
_layer.type = (exLayer.Type)EditorGUI.EnumPopup(new Rect(_rect.width - 60.0f * 2.0f - 20.0f, 2, 70.0f, _rect.height - 4), _layer.type);
GUI.backgroundColor = oldBGColor;
GUI.contentColor = oldColor;
EditorGUIUtility.LookLikeControls();
// draw range
if (_layer.type == exLayer.Type.Dynamic)
{
_layer.range = EditorGUI.IntField(new Rect(_rect.width - 60.0f * 1.0f - 5.0f, 2, 60.0f, _rect.height - 4), _layer.range);
}
GUI.EndGroup();
//
if (GUI.changed)
{
EditorUtility.SetDirty(_layer);
}
//
layers.Add(_layer);
// ========================================================
// process mouse event
Event e = Event.current;
// ========================================================
if (_rect.Contains(e.mousePosition))
{
if (e.type == EventType.MouseDown && e.button == 0 && e.clickCount == 1)
{
if (_layer != curLayer)
{
if (e.command || e.control)
{
ToggleSelected(_layer);
}
else if (e.shift)
{
doShiftSelect = true;
lastShiftClick = curShiftClick;
curShiftClick = _layer;
}
else
{
if (selected == false)
{
selectedLayers.Clear();
AddSelected(_layer);
shiftClickStart = _layer;
}
}
layerCursorIn = null;
e.Use();
Repaint();
}
doDrag = true;
}
else if (inDragState == false &&
e.type == EventType.MouseUp &&
e.button == 0 &&
e.clickCount == 1 &&
e.command == false &&
e.control == false &&
e.shift == false)
{
if (_layer != curLayer)
{
selectedLayers.Clear();
AddSelected(_layer);
layerCursorIn = null;
e.Use();
Repaint();
}
}
else if (e.type == EventType.MouseDrag)
{
if (inDragState)
{
if (_layer != curLayer)
{
layerCursorIn = _layer;
Repaint();
}
}
else if (selected && doDrag)
{
inDragState = true;
doDrag = false;
}
e.Use();
Repaint();
}
}
GUILayoutUtility.GetRect(_rect.width, _rect.height);
// ========================================================
// draw the child
// ========================================================
curY += layerFieldHeight - 1;
if (_layer.foldout)
{
foreach (exLayer child in _layer.children)
{
curY = LayerField(new Rect(_rect.x, curY, _rect.width, layerFieldHeight),
_indentLevel + 1,
child);
}
}
return(curY);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void LayerTreeField( float _x, float _y, exLayer _layer )
{
//
layers.Clear();
Rect layerFieldRect = new Rect ( _x, _y, position.width - 2.0f * _x, layerFieldHeight );
// DISABLE {
// float totalLayerHeight = LayerField ( layerFieldRect, 0, _layer );
// GUILayoutUtility.GetRect ( layerFieldRect.width, totalLayerHeight );
LayerField ( layerFieldRect, 0, _layer );
// } DISABLE end
// ========================================================
// process drag
// ========================================================
if ( inDragState && layerCursorIn != null ) {
bool insertLayerSelected = selectedLayers.IndexOf(layerCursorIn) != -1;
int index = 0;
index = layers.IndexOf(layerCursorIn);
Rect rect = new Rect( _x,
_y + index * (layerFieldHeight) - index,
position.width - 2.0f * _x,
layerFieldHeight );
int hlIndex = -1;
//
if ( Event.current.mousePosition.y <= rect.y + rect.height * 0.5f ) {
index = layers.IndexOf(layerCursorIn);
exLayer prevLayer = (index-1 < 0) ? null : layers[index-1];
// up
if ( prevLayer != null &&
( selectedLayers.IndexOf(prevLayer) == -1 ||
insertLayerSelected == false ) )
{
hlIndex = index-1;
exEditorHelper.DrawRect( new Rect( rect.x, rect.y+1 - rect.height * 0.1f, rect.width, rect.height * 0.2f ),
new Color( 1.0f, 1.0f, 0.0f, 1.0f ),
new Color( 1.0f, 1.0f, 0.0f, 1.0f ) );
}
}
else if ( Event.current.mousePosition.y > rect.y + rect.height * 0.5f ) {
index = layers.IndexOf(layerCursorIn);
exLayer nextLayer = (index > layers.Count-1) ? null : layers[index];
int nextIndexInSelection = selectedLayers.IndexOf(nextLayer);
// down
if ( nextLayer != null &&
( nextIndexInSelection == -1 ||
nextIndexInSelection == selectedLayers.Count-1 ||
insertLayerSelected == false ) )
{
hlIndex = index;
exEditorHelper.DrawRect( new Rect( rect.x, rect.y + rect.height * 0.9f, rect.width, rect.height * 0.2f ),
new Color( 1.0f, 1.0f, 0.0f, 1.0f ),
new Color( 1.0f, 1.0f, 0.0f, 1.0f ) );
}
}
//
exLayer hlLayer = null;
exLayer insertLayer = null;
exLayer insertLayerNext = null;
// highlight the layer for insert
if ( hlIndex != -1 ) {
insertLayer = layers[hlIndex];
insertLayerNext = (hlIndex == layers.Count-1) ? null : layers[hlIndex+1];
hlLayer = layers[hlIndex];
float indentX = _x + hlLayer.indentLevel * 15.0f + 10.0f;
if ( hlLayer.children.Count == 0 ) {
indentX += 15.0f;
}
while ( selectedLayers.IndexOf(hlLayer) != -1 || Event.current.mousePosition.x <= indentX ) {
exLayer hlParent = hlLayer.parent;
if ( hlParent == null )
break;
if ( insertLayerNext != null &&
(insertLayerNext.indentLevel - hlParent.indentLevel) >= 2 )
{
break;
}
//
hlLayer = hlParent;
indentX = _x + hlLayer.indentLevel * 15.0f + 10.0f;
if ( hlLayer.children.Count == 0 ) {
indentX += 15.0f;
}
}
hlIndex = layers.IndexOf(hlLayer);
}
// again
if ( hlIndex != -1 ) {
exEditorHelper.DrawRect( new Rect( _x,
_y + hlIndex * (layerFieldHeight) - hlIndex,
position.width - 2.0f * _x,
layerFieldHeight ),
new Color( 0.0f, 1.0f, 0.0f, 0.2f ),
new Color( 0.0f, 0.0f, 0.0f, 0.0f ) );
}
//
if ( (Event.current.type == EventType.MouseUp && Event.current.button == 0) ||
(Event.current.type == EventType.KeyDown && Event.current.keyCode == KeyCode.Escape) ) {
inDragState = false;
if ( hlIndex != -1 && Event.current.type == EventType.MouseUp ) {
//
if ( sortSelection ) {
SortSelection();
sortSelection = false;
}
List<exLayer> insertList = new List<exLayer>();
foreach ( exLayer layer in selectedLayers ) {
if ( selectedLayers.IndexOf(layer.parent) == -1 ) {
insertList.Add(layer);
}
}
// get exact insert layer
while ( (insertLayer.indentLevel - hlLayer.indentLevel) > 1 ) {
insertLayer = insertLayer.parent;
}
if ( hlLayer.children.Count == 0 ) {
foreach ( exLayer layer in insertList ) {
if ( layer.parent != null )
EditorUtility.SetDirty(layer.parent);
layer.parent = hlLayer;
EditorUtility.SetDirty(layer);
}
}
else {
for ( int i = insertList.Count-1; i >=0; --i ) {
int insertIdx = hlLayer.children.IndexOf(insertLayer) + 1;
if ( insertList[i].parent != null )
EditorUtility.SetDirty(insertList[i].parent);
hlLayer.InsertAt ( insertIdx, insertList[i] );
EditorUtility.SetDirty(insertList[i]);
}
}
EditorUtility.SetDirty(hlLayer);
}
//
EditorUtility.SetDirty(curLayer);
Event.current.Use();
Repaint();
}
}
// ========================================================
// do shift select
// ========================================================
if ( doShiftSelect ) {
doShiftSelect = false;
//
int idx1 = layers.IndexOf(shiftClickStart);
int idx2 = layers.IndexOf(lastShiftClick);
if ( idx1 != -1 && idx2 != -1 ) {
if ( idx1 > idx2 ) {
int tmp = idx1;
idx1 = idx2;
idx2 = tmp;
}
for ( int i = idx1; i <= idx2; ++i ) {
RemoveSelected(layers[i]);
}
}
//
idx1 = layers.IndexOf(shiftClickStart);
idx2 = layers.IndexOf(curShiftClick);
if ( idx1 != -1 && idx2 != -1 ) {
if ( idx1 > idx2 ) {
int tmp = idx1;
idx1 = idx2;
idx2 = tmp;
}
for ( int i = idx1; i <= idx2; ++i ) {
AddSelected(layers[i]);
}
}
}
// ========================================================
// process delete
// ========================================================
if ( Event.current.type == EventType.KeyDown &&
( Event.current.keyCode == KeyCode.Delete ||
Event.current.keyCode == KeyCode.Backspace ) )
{
List<exLayer> deleteList = new List<exLayer>();
foreach ( exLayer layer in selectedLayers ) {
if ( selectedLayers.IndexOf(layer.parent) == -1 ) {
deleteList.Add(layer);
}
}
selectedLayers.Clear();
foreach ( exLayer layer in deleteList ) {
layer.parent = null;
EditorUtility.SetDirty(layer);
}
//
EditorUtility.SetDirty(curLayer);
Event.current.Use();
Repaint();
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
float LayerField( Rect _rect, int _indentLevel, exLayer _layer )
{
if ( _layer == null )
return _rect.y;
// get selected
bool selected = selectedLayers.IndexOf(_layer) != -1;
// ========================================================
// draw field
// ========================================================
// draw rect
exEditorHelper.DrawRect( _rect,
selected ? new Color( 0.0f, 0.4f, 0.8f, 1.0f ) : new Color( 0.25f, 0.25f, 0.25f, 1.0f ),
new Color( 0.0f, 0.0f, 0.0f, 1.0f ) );
float curX = _rect.x;
float curY = _rect.y;
GUI.BeginGroup( _rect );
// draw foldout
curX += _indentLevel * 15.0f + 10.0f;
if ( _layer.children.Count > 0 ) {
_layer.foldout = EditorGUI.Foldout ( new Rect ( curX, 2, 20, _rect.height-2 ), _layer.foldout, "" );
}
curX += 20;
_layer.indentLevel = _indentLevel;
// draw label
GUI.Label ( new Rect ( curX, 1, _rect.width - curX, _rect.height - 2 ), _layer.name );
// draw enum
EditorGUIUtility.LookLikeInspector ();
Color oldColor = GUI.contentColor;
Color oldBGColor = GUI.backgroundColor;
switch ( _layer.type ) {
case exLayer.Type.Dynamic:
GUI.backgroundColor = Color.green;
GUI.contentColor = Color.green;
break;
case exLayer.Type.Abstract:
GUI.backgroundColor = Color.yellow;
GUI.contentColor = Color.yellow;
break;
}
_layer.type = (exLayer.Type)EditorGUI.EnumPopup ( new Rect ( _rect.width - 60.0f * 2.0f - 20.0f, 2, 70.0f, _rect.height - 4 ), _layer.type );
GUI.backgroundColor = oldBGColor;
GUI.contentColor = oldColor;
EditorGUIUtility.LookLikeControls ();
// draw range
if (_layer.type == exLayer.Type.Dynamic) {
_layer.range = EditorGUI.IntField ( new Rect ( _rect.width - 60.0f * 1.0f - 5.0f, 2, 60.0f, _rect.height - 4 ), _layer.range );
}
GUI.EndGroup();
//
if ( GUI.changed ) {
EditorUtility.SetDirty(_layer);
}
//
layers.Add(_layer);
// ========================================================
// process mouse event
Event e = Event.current;
// ========================================================
if ( _rect.Contains( e.mousePosition ) ) {
if ( e.type == EventType.MouseDown && e.button == 0 && e.clickCount == 1 ) {
if ( _layer != curLayer ) {
if ( e.command || e.control ) {
ToggleSelected(_layer);
}
else if ( e.shift ) {
doShiftSelect = true;
lastShiftClick = curShiftClick;
curShiftClick = _layer;
}
else {
if ( selected == false ) {
selectedLayers.Clear();
AddSelected(_layer);
shiftClickStart = _layer;
}
}
layerCursorIn = null;
e.Use();
Repaint();
}
doDrag = true;
}
else if ( inDragState == false &&
e.type == EventType.MouseUp &&
e.button == 0 &&
e.clickCount == 1 &&
e.command == false &&
e.control == false &&
e.shift == false )
{
if ( _layer != curLayer ) {
selectedLayers.Clear();
AddSelected(_layer);
layerCursorIn = null;
e.Use();
Repaint();
}
}
else if ( e.type == EventType.MouseDrag ) {
if ( inDragState ) {
if ( _layer != curLayer ) {
layerCursorIn = _layer;
Repaint();
}
}
else if ( selected && doDrag ) {
inDragState = true;
doDrag = false;
}
e.Use();
Repaint();
}
}
GUILayoutUtility.GetRect ( _rect.width, _rect.height );
// ========================================================
// draw the child
// ========================================================
curY += layerFieldHeight-1;
if ( _layer.foldout ) {
foreach ( exLayer child in _layer.children ) {
curY = LayerField ( new Rect ( _rect.x, curY, _rect.width, layerFieldHeight ),
_indentLevel + 1,
child );
}
}
return curY;
}
void LayerElementField( Rect _rect, exLayer _layer, int _controlID )
{
Vector2 size = Vector2.zero;
float cur_x = _rect.x;
Event e = Event.current;
if ( _layer == null )
return;
cur_x += 5.0f;
Rect draggingHandleRect = new Rect(cur_x, _rect.y + 10f, 10f, _rect.height);
if ( Event.current.type == EventType.Repaint ) {
// draw background
if ( activeLayer == _layer ) {
settingsStyles.elementSelectionRect.Draw(_rect, false, false, false, false);
}
else {
settingsStyles.elementBackground.Draw(_rect, false, false, false, false);
}
settingsStyles.draggingHandle.Draw( draggingHandleRect, false, false, false, false );
EditorGUIUtility.AddCursorRect ( draggingHandleRect, MouseCursor.Pan );
}
cur_x += 10.0f;
// show
cur_x += 5.0f;
size = EditorStyles.toggle.CalcSize( GUIContent.none );
bool newShow = EditorGUI.Toggle ( new Rect ( cur_x, _rect.y + 3f, size.x, size.y ),
_layer.show );
if ( newShow != _layer.show ) {
_layer.show = newShow;
EditorUtility.SetDirty(_layer);
}
cur_x += 10.0f;
// layer name
cur_x += 10.0f;
string newName = EditorGUI.TextField ( new Rect ( cur_x, _rect.y + 4f, 100f, _rect.height - 8f ),
_layer.gameObject.name );
if ( newName != _layer.gameObject.name ) {
_layer.gameObject.name = newName;
EditorUtility.SetDirty(_layer.gameObject);
}
cur_x += 100.0f;
if (ex2DRenderer.instance.customizeLayerZ) {
// custom z
cur_x += 10.0f;
string z_text = EditorGUI.TextField (new Rect (cur_x, _rect.y + 4f, 40f, _rect.height - 8f),
_layer.customZ.ToString ());
float z;
if (float.TryParse (z_text, out z) && _layer.customZ != z) {
_layer.customZ = z;
EditorUtility.SetDirty (_layer.gameObject);
}
cur_x += 40.0f;
}
//
size = settingsStyles.removeButton.CalcSize( new GUIContent(settingsStyles.iconToolbarMinus) );
cur_x = _rect.xMax - 5.0f - size.x;
if ( GUI.Button( new Rect( cur_x, _rect.y + 2f, size.x, size.y ),
settingsStyles.iconToolbarMinus,
settingsStyles.removeButton) )
{
if ( EditorUtility.DisplayDialog ( "Delete Layer?",
string.Format("Are you sure you want to delete _layer: {0}?", _layer.gameObject.name),
"Yes",
"No" ) )
{
ex2DRenderer.instance.DestroyLayer(_layer);
}
}
// event process for _layer
switch ( e.GetTypeForControl(_controlID) ) {
case EventType.MouseDown:
if ( e.button == 0 && e.clickCount == 1 && _rect.Contains(e.mousePosition) ) {
GUIUtility.hotControl = _controlID;
GUIUtility.keyboardControl = _controlID;
activeLayer = _layer;
if ( draggingHandleRect.Contains(e.mousePosition) ) {
// draggingLayer = _layer; TODO
}
e.Use();
}
break;
}
}
void SceneViewField( Rect _rect )
{
int controlID = GUIUtility.GetControlID(sceneViewFieldHash, FocusType.Passive);
Event e = Event.current;
switch ( e.type ) {
case EventType.Repaint:
// GUIStyle previewBackground = "AnimationCurveEditorBackground";
// previewBackground.Draw(_rect, false, false, false, false);
sceneViewRect = _rect;
// draw scene
DoCulling (sceneViewRect);
DrawScene (sceneViewRect);
break;
case EventType.ScrollWheel:
if ( _rect.Contains(e.mousePosition) ) {
scale += -e.delta.y * 0.01f;
Repaint();
e.Use();
}
break;
case EventType.MouseDown:
if ( _rect.Contains(e.mousePosition) ) {
if ( e.button == 1 && e.clickCount == 1 ) {
GUIUtility.hotControl = controlID;
GUIUtility.keyboardControl = controlID;
Repaint();
e.Use();
}
}
break;
case EventType.MouseDrag:
if ( GUIUtility.hotControl == controlID ) {
editCamera.transform.position += new Vector3 ( -e.delta.x / scale, e.delta.y / scale, 0.0f );
Repaint();
e.Use();
}
break;
case EventType.MouseUp:
if ( GUIUtility.hotControl == controlID ) {
GUIUtility.hotControl = 0;
Repaint();
e.Use();
}
break;
case EventType.DragUpdated:
if ( ex2DRenderer.instance.layerList.Count > 0 && _rect.Contains(e.mousePosition) ) {
if ( activeLayer == null ) {
activeLayer = ex2DRenderer.instance.layerList[0];
}
// Show a copy icon on the drag
foreach ( Object o in DragAndDrop.objectReferences ) {
if ( o is exTextureInfo ||
o is exBitmapFont ||
o is Font ||
o is exSpriteAnimationClip )
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
break;
}
}
draggingObjects.Clear();
foreach ( Object o in DragAndDrop.objectReferences ) {
draggingObjects.Add(o);
}
Repaint();
e.Use();
}
break;
case EventType.DragPerform:
if ( _rect.Contains(e.mousePosition) ) {
DragAndDrop.AcceptDrag();
foreach ( Object o in DragAndDrop.objectReferences ) {
GameObject newGO = null;
if ( o is exTextureInfo ) {
newGO = new GameObject(o.name);
exSprite sprite = newGO.AddComponent<exSprite>();
sprite.textureInfo = o as exTextureInfo;
InitSprite(sprite);
}
else if ( o is exBitmapFont ) {
newGO = new GameObject(o.name);
exSpriteFont spriteFont = newGO.AddComponent<exSpriteFont>();
spriteFont.shader = Shader.Find("ex2D/Alpha Blended");
spriteFont.SetFont(o as exBitmapFont);
}
else if ( o is Font ) {
newGO = new GameObject(o.name);
exSpriteFont spriteFont = newGO.AddComponent<exSpriteFont>();
spriteFont.shader = Shader.Find("ex2D/Alpha Blended (Use Vertex Color)");
spriteFont.SetFont(o as Font);
}
else if ( o is exSpriteAnimationClip ) {
exSpriteAnimationClip clip = o as exSpriteAnimationClip;
newGO = new GameObject(o.name);
exSprite sprite = newGO.AddComponent<exSprite>();
sprite.shader = Shader.Find("ex2D/Alpha Blended");
exSpriteAnimation spriteAnim = newGO.AddComponent<exSpriteAnimation>();
spriteAnim.defaultAnimation = clip;
spriteAnim.animations.Add(clip);
if ( clip.frameInfos.Count > 0 ) {
sprite.textureInfo = clip.frameInfos[0].textureInfo;
}
InitSprite(sprite);
}
if ( newGO != null && activeLayer != null ) {
newGO.transform.position = SceneField_MapToWorld( _rect, e.mousePosition);
newGO.transform.localScale = Vector3.one;
newGO.transform.rotation = Quaternion.identity;
activeLayer.Add(newGO);
EditorUtility.SetDirty(activeLayer);
EditorUtility.SetDirty(newGO);
Selection.activeObject = newGO;
}
}
Repaint();
e.Use();
}
break;
case EventType.DragExited:
draggingObjects.Clear();
Repaint();
break;
}
}
///////////////////////////////////////////////////////////////////////////////
// functions
///////////////////////////////////////////////////////////////////////////////
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void Reset()
{
curSerializedObject = null;
activeLayer = null;
// draggingLayer = null; TODO
if ( ex2DRenderer.instance ) {
ex2DRenderer.instance.ForceRenderScene();
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void CalculateDepthForDynamicLayer( exLayer _curLayer, bool _doAssign )
{
float totalDepth = 0.0f;
List<exLayer> layerList = new List<exLayer>();
AddLayerRecursively ( _curLayer, true, ref totalDepth, ref layerList );
if ( layerList.Count > 1 ) {
float unitLayer = (float)_curLayer.range/(float)(layerList.Count-1);
float curDepth = _curLayer.depth;
for ( int i = 0; i < layerList.Count; ++i ) {
exLayer layer = layerList[i];
layer.depth = curDepth;
layer.isDirty = true;
if ( layer.type == exLayer.Type.Normal ) {
curDepth += unitLayer;
}
}
// assignment
if ( _doAssign ) {
for ( int i = 0; i < layerList.Count; ++i ) {
exLayer layer = layerList[i];
if ( layer.isDirty == false )
continue;
RecursivelyUpdateLayer ( layer.transform.root );
}
}
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void OnGUI()
{
EditorGUI.indentLevel = 0;
// ========================================================
// check if selection valid
// ========================================================
//
if ( curEditGO == null ) {
GUILayout.Space(10);
GUILayout.Label ( "Please select a GameObject for editing" );
return;
}
//
if ( curEditGO.GetComponent<Camera>() ) {
curLayer = curEditGO.GetComponent<exLayerMng>();
if ( curLayer == null ) {
if ( GUILayout.Button ( "Add Layer Manager", GUILayout.Width(200) ) ) {
curLayer = curEditGO.AddComponent<exLayerMng> ();
}
}
}
else {
//
curLayer = curEditGO.GetComponent<exLayer>();
if ( curLayer == null ) {
GUILayout.Space(10);
GUILayout.Label ( "There is no edit layer in this GameObject" );
return;
}
}
//
if ( curLayer == null ) {
GUILayout.Label ( "Invalid GameObject" );
return;
}
// ========================================================
// toolbar
// ========================================================
GUILayout.BeginHorizontal ( EditorStyles.toolbar );
// ========================================================
// update button
// ========================================================
GUILayout.FlexibleSpace();
exLayerMng layerMng = curLayer as exLayerMng;
GUI.enabled = (layerMng != null);
if ( GUILayout.Button( "Update", EditorStyles.toolbarButton ) ) {
layerMng.AddDirtyLayer(layerMng);
EditorUtility.SetDirty(layerMng);
}
GUI.enabled = true;
GUILayout.Space(5);
// ========================================================
// lock button
// ========================================================
lockSelection = GUILayout.Toggle ( lockSelection, "Lock", EditorStyles.toolbarButton );
GUILayout.EndHorizontal ();
// ========================================================
// scroll view
// ========================================================
float toolbarHeight = EditorStyles.toolbar.CalcHeight( new GUIContent(""), 0 );
scrollPos = EditorGUILayout.BeginScrollView ( scrollPos,
GUILayout.Width(position.width),
GUILayout.Height(position.height-toolbarHeight) );
GUILayout.Space(10);
// ========================================================
// draw the tree
// ========================================================
//
float space = 5.0f;
Rect lastRect = GUILayoutUtility.GetLastRect ();
LayerTreeField ( space, lastRect.yMax, curLayer );
GUILayout.Space(5);
// ========================================================
// Clear All Layer Button
// ========================================================
Color oldBGColor = GUI.backgroundColor;
Color oldCTColor = GUI.contentColor;
GUI.backgroundColor = Color.red;
GUI.contentColor = Color.yellow;
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if ( GUILayout.Button("Remove All Layers", GUILayout.Width(120) ) ) {
bool doRemove = EditorUtility.DisplayDialog( "Warning!",
"This operation will remove all exLayer Component in the editor, do you want to continue operation",
"Yes", "No" );
if ( doRemove ) {
RecursivelyDestroyLayer (curLayer);
}
}
GUILayout.EndHorizontal();
GUI.backgroundColor = oldBGColor;
GUI.contentColor = oldCTColor;
// ========================================================
// process mouse event
Event e = Event.current;
// ========================================================
if ( e.type == EventType.MouseDown && e.button == 0 && e.clickCount == 1 ) {
selectedLayers.Clear();
e.Use();
Repaint();
}
else if ( e.type == EventType.MouseUp ) {
inDragState = false;
e.Use();
Repaint();
}
// do add GameObject to layerMng
else if ( e.type == EventType.DragUpdated ) {
// Show a copy icon on the drag
foreach ( Object o in DragAndDrop.objectReferences ) {
if ( o is GameObject ) {
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
break;
}
}
}
else if ( e.type == EventType.DragPerform ) {
DragAndDrop.AcceptDrag();
try {
EditorUtility.DisplayProgressBar( "Add new layer items", "Add new layer itmes...", 0.5f );
//
Object oldSelActiveObject = null;
List<Object> oldSelObjects = new List<Object>();
foreach ( Object o in Selection.objects ) {
oldSelObjects.Add(o);
}
oldSelActiveObject = Selection.activeObject;
//
List<exLayer> addedLayers = new List<exLayer>();
List<exLayer> newLayers = new List<exLayer>();
foreach ( Object o in DragAndDrop.objectReferences ) {
// never add self, it cause dead loop
if ( o == curEditGO )
continue;
//
Selection.activeObject = o;
Object[] objects = Selection.GetFiltered( typeof(GameObject), SelectionMode.Deep);
foreach ( Object obj in objects ) {
if ( obj ) {
GameObject go = obj as GameObject;
exLayer layer = go.GetComponent<exLayer>();
if ( layer == null ) {
layer = go.AddComponent<exLayer>();
newLayers.Add(layer);
}
if ( addedLayers.IndexOf(layer) == -1 ) {
addedLayers.Add(layer);
}
}
}
}
// sync new layer's parent
foreach ( exLayer layer in newLayers ) {
Transform parent = layer.transform.parent;
while ( parent != null ) {
exLayer parentLayer = parent.GetComponent<exLayer>();
if ( parentLayer ) {
layer.parent = parentLayer;
break;
}
parent = parent.parent;
}
}
//
List<exLayer> parentOfNewLayers = new List<exLayer>();
foreach ( exLayer li in addedLayers ) {
if ( addedLayers.IndexOf(li.parent) == -1 ) {
parentOfNewLayers.Add(li);
}
}
foreach ( exLayer li in parentOfNewLayers ) {
if ( li.parent != null )
EditorUtility.SetDirty(li.parent);
li.ForceSetParent(curLayer);
EditorUtility.SetDirty(li);
}
EditorUtility.SetDirty(curLayer);
//
Selection.objects = oldSelObjects.ToArray();
Selection.activeObject = oldSelActiveObject;
EditorUtility.ClearProgressBar();
}
catch ( System.Exception ) {
EditorUtility.ClearProgressBar();
throw;
}
Repaint();
}
EditorGUILayout.EndScrollView();
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void RecursivelyDestroyLayer( exLayer _layer )
{
for ( int i = _layer.children.Count-1; i >= 0; --i ) {
exLayer childLayer = _layer.children[i];
RecursivelyDestroyLayer (childLayer);
GameObject.DestroyImmediate(childLayer);
}
if ( (_layer is exLayerMng) == false )
GameObject.DestroyImmediate(_layer);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void RemoveSelected( exLayer _l )
{
if ( _l == null )
return;
bool parentInSelect = false;
exLayer parent = _l.parent;
while ( parent != null ) {
if ( selectedLayers.IndexOf(parent) != -1 ) {
parentInSelect = true;
break;
}
parent = parent.parent;
}
//
if ( parentInSelect == false ) {
selectedLayers.Remove(_l);
foreach ( exLayer l in _l.children ) {
RemoveSelected (l);
}
}
sortSelection = true;
List<GameObject> goList = new List<GameObject>();
foreach ( exLayer layer in selectedLayers ) {
goList.Add(layer.gameObject);
}
Selection.objects = goList.ToArray();
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void UpdateLayers()
{
if (updateAll)
{
updateAll = false;
//
List <exLayer> layerList = new List <exLayer>();
List <exLayer> specialLayerList = new List <exLayer>();
float totalDepth = camera.farClipPlane - camera.nearClipPlane;
totalDepth -= 0.2f; // we leave 1.0 for both near and far clip
float startFrom = transform.position.z + camera.nearClipPlane + 0.1f;
int totalNormalLayerCount = 0;
foreach (exLayer childLayer in children)
{
childLayer.indentLevel = 1;
totalNormalLayerCount += AddLayerRecursively(childLayer, true, ref totalDepth, ref layerList);
}
//
float unitLayer = totalDepth / totalNormalLayerCount;
// normal layer depth calcualte
const int MAX_INDENT = 99999;
int specialIndentLevel = MAX_INDENT;
float curDepth = startFrom + unitLayer; // skip layerMng
for (int i = 0; i < layerList.Count; ++i)
{
exLayer layer = layerList[i];
layer.depth = curDepth;
if (layer.type != exLayer.Type.Normal)
{
specialLayerList.Add(layer);
specialIndentLevel = layer.indentLevel;
if (layer.type == exLayer.Type.Dynamic)
{
curDepth += layer.range;
}
else if (layer.type == exLayer.Type.Abstract)
{
curDepth += unitLayer;
}
}
else
{
if (layer.indentLevel <= specialIndentLevel)
{
// Debug.Log( layer.gameObject.name + " curDepth = " + curDepth + " , " + specialIndentLevel );
specialIndentLevel = MAX_INDENT;
curDepth += unitLayer;
}
}
}
// special layer depth calculate
for (int i = 0; i < specialLayerList.Count; ++i)
{
exLayer layer = specialLayerList[i];
if (layer.type == exLayer.Type.Dynamic)
{
CalculateDepthForDynamicLayer(layer, false);
}
else if (layer.type == exLayer.Type.Abstract)
{
CalculateDepthForAbstractLayer(layer, false);
}
}
// assignment
for (int i = 0; i < layerList.Count; ++i)
{
exLayer layer = layerList[i];
if (layer.isDirty == false)
{
continue;
}
RecursivelyUpdateLayer(layer.transform.root);
}
}
else
{
// re-update special layers
for (int i = 0; i < dirtyLayers.Count; ++i)
{
exLayer layer = dirtyLayers[i];
if (layer.type == exLayer.Type.Dynamic)
{
CalculateDepthForDynamicLayer(layer, true);
}
else if (layer.type == exLayer.Type.Abstract)
{
CalculateDepthForAbstractLayer(layer, true);
}
}
}
dirtyLayers.Clear();
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void ToggleSelected( exLayer _l )
{
int i = selectedLayers.IndexOf(_l);
if ( i != -1 ) {
RemoveSelected(_l);
}
else {
AddSelected (_l);
}
}
// ------------------------------------------------------------------
// Desc:
// NOTE: only used in Editor
// ------------------------------------------------------------------
public void ForceSetParent( exLayer _parent )
{
// check if it is parent layer or child
exLayer parentLayer = _parent;
exLayer lastLayer = this;
while ( parentLayer != null ) {
if ( parentLayer == this ) {
Debug.LogWarning("can't add self or child as parent");
return;
}
lastLayer = parentLayer;
parentLayer = lastLayer.parent;
}
//
if ( parent_ ) {
parent_.children_.Remove(this);
}
//
if ( _parent ) {
_parent.children_.Add(this);
}
// update layer mng
parentLayer = (parent_ == null ? _parent : parent_);
lastLayer = this;
while ( parentLayer != null ) {
lastLayer = parentLayer;
parentLayer = lastLayer.parent;
}
exLayerMng layerMng = lastLayer as exLayerMng;
if ( layerMng ) {
layerMng.AddDirtyLayer(layerMng);
}
//
parent_ = _parent;
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
bool GetExactLayerIndex( ref int _index, exLayer _curLayer, exLayer _l )
{
if ( _curLayer == _l )
return true;
for ( int i = 0; i < _curLayer.children.Count; ++i ) {
_index += 1;
exLayer childLayer = _curLayer.children[i];
if ( childLayer == _l ) {
return true;
}
bool found = GetExactLayerIndex ( ref _index, childLayer, _l );
if ( found )
return true;
}
return false;
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public bool HasLayer(exLayer _layer)
{
return(layerList.Contains(_layer));
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void SetLayerDepthRecursively( exLayer _curLayer, float _depth )
{
_curLayer.depth = _depth;
for ( int i = 0; i < _curLayer.children.Count; ++i ) {
SetLayerDepthRecursively ( _curLayer.children[i], _depth );
}
}
public void UpdateDebugName(exLayer layer = null)
{
#if EX_DEBUG
if (ReferenceEquals(layer, null) == false) {
layerForDebug = layer;
}
string matName;
Material mat = material;
if (mat != null) {
if (mat.mainTexture) {
matName = mat.mainTexture.name;
}
else {
matName = mat.name;
}
}
else {
matName = "None";
}
gameObject.name = string.Format("_exMesh@{0}({1})", layerForDebug.name, matName);
if (mesh0 != null) {
mesh0.name = gameObject.name + "_0";
}
if (mesh1 != null) {
mesh1.name = gameObject.name + "_1";
}
#endif
}
public void DestroyLayer(exLayer _layer)
{
exDebug.Assert(layerList.Contains(_layer), "can't find layer in ex2DRenderer");
layerList.Remove(_layer);
if (_layer != null) {
#if EX_DEBUG
Debug.Log("DestroyLayer " + _layer.gameObject.name);
#endif
_layer.gameObject.Destroy();
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void SetLayerDepthRecursively ( exLayer _curLayer, float _depth ) {
_curLayer.depth = _depth;
foreach ( exLayer childLayer in _curLayer.children ) {
SetLayerDepthRecursively ( childLayer, _depth );
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public bool HasLayer(exLayer _layer)
{
return layerList.Contains(_layer);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
List<exLayer> CalculateDepthForAbstractLayer ( exLayer _curLayer ) {
float totalDepth = 0.0f;
List<exLayer> layerList = new List<exLayer>();
AddLayerRecursively ( _curLayer, true, ref totalDepth, ref layerList );
float curDepth = _curLayer.depth;
for ( int i = 0; i < layerList.Count; ++i ) {
exLayer layer = layerList[i];
layer.depth = curDepth;
layer.isDirty = true;
}
return layerList;
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void InsertLayer( int _idx, exLayer _layer )
{
_idx = Mathf.Clamp(_idx, 0, layerList.Count);
if (layerList.Contains(_layer)) {
Debug.LogWarning("Layer already exists in ex2DRenderer: " + _layer, _layer);
return;
}
#if EX_DEBUG
Debug.Log("InsertLayer " + _layer.gameObject.name + " to " + _idx);
#endif
layerList.Insert( _idx, _layer );
//
_layer.GenerateMeshes();
ResortLayerDepth();
}
protected virtual void Awake()
{
//get the reference of playmaker fsms.
PlayMakerFSM[] fsms = GetComponents<PlayMakerFSM>();
foreach (PlayMakerFSM fsm in fsms) {
if (fsm.FsmName == "FSM_Control") {
FSM_Control = fsm;
}
if (fsm.FsmName == "FSM_Hit") {
FSM_Hit = fsm;
}
if (fsm.FsmName == "FSM_Charge") {
FSM_Charge = fsm;
}
}
//initialize key variables.
player = transform.GetComponent<PlayerBase>();
layer = GetComponent<exLayer>();
velocity = new Vector2(0, 0);
comboLevel = 0;
charMoveDir = MoveDir.Stop;
downButton = BtnHoldState.None;
initJumpSpeedStatic = jumpSpeed;
initMoveSpeedStatic = moveSpeed;
initAttackPowerStatic = attackPower;
initInvincibleDuration = FSM_Hit.FsmVariables.GetFsmFloat("varInvincibleDuration").Value;
currentPlatform = Game.instance.theBasePlatform;
}
// ------------------------------------------------------------------
/// 只重设layer相关属性，但不真的从layer或mesh中删除。
// ------------------------------------------------------------------
void exLayer.IFriendOfLayer.ResetLayerProperties()
{
layer_ = null;
isInIndexBuffer = false;
}
