| public UpdateGeometry ( Matrix4x4 &worldToPanel, bool parentMoved, bool generateNormals ) : bool | ||
| worldToPanel | Matrix4x4 | |
| parentMoved | bool | |
| generateNormals | bool | |
| return | bool | |
private void UpdateWidgets()
{
bool flag = false;
bool flag2 = false;
bool hasCumulativeClipping = this.hasCumulativeClipping;
if (!this.cullWhileDragging)
{
for (int i = 0; i < UIScrollView.list.size; i++)
{
UIScrollView uIScrollView = UIScrollView.list[i];
if (uIScrollView.panel == this && uIScrollView.isDragging)
{
flag2 = true;
}
}
}
if (this.mForced != flag2)
{
this.mForced = flag2;
this.mResized = true;
}
int frameCount = Time.frameCount;
int j = 0;
int count = this.widgets.Count;
while (j < count)
{
UIWidget uIWidget = this.widgets[j];
if (uIWidget.panel == this && uIWidget.enabled)
{
if (uIWidget.UpdateTransform(frameCount) || this.mResized)
{
bool visibleByAlpha = flag2 || uIWidget.CalculateCumulativeAlpha(frameCount) > 0.001f;
uIWidget.UpdateVisibility(visibleByAlpha, flag2 || (!hasCumulativeClipping && !uIWidget.hideIfOffScreen) || this.IsVisible(uIWidget));
}
if (uIWidget.UpdateGeometry(frameCount))
{
flag = true;
if (!this.mRebuild)
{
if (uIWidget.drawCall != null)
{
uIWidget.drawCall.isDirty = true;
}
else
{
this.FindDrawCall(uIWidget);
}
}
}
}
j++;
}
if (flag && this.onGeometryUpdated != null)
{
this.onGeometryUpdated();
}
this.mResized = false;
}
// update all widgets
void UpdateWidgets()
{
bool changed = false;
for (int i = 0, imax = widgets.size; i < imax; ++i)
{
UIWidget w = widgets.buffer[i];
if (w.panel == this && w.enabled)
{
int frame = Time.frameCount;
if (w.UpdateTransform(frame))
{
}
if (w.UpdateGeometry(frame))
{
changed = true;
if (!mRebuild)
{
if (w.drawCall != null)
{
w.drawCall.isDirty = true;
}
else
{
FindDrawCall(w);
}
}
}
}
}
}
private void LateUpdate()
{
this.mUpdateTime = Time.realtimeSinceStartup;
this.UpdateTransformMatrix();
if (this.mLayer != this.cachedGameObject.layer)
{
this.mLayer = this.mGo.layer;
UICamera uicamera = UICamera.FindCameraForLayer(this.mLayer);
this.mCam = ((!(uicamera != null)) ? NGUITools.FindCameraForLayer(this.mLayer) : uicamera.cachedCamera);
UIPanel.SetChildLayer(this.cachedTransform, this.mLayer);
int i = 0;
int size = this.drawCalls.size;
while (i < size)
{
this.mDrawCalls.buffer[i].gameObject.layer = this.mLayer;
i++;
}
}
bool forceVisible = !this.cullWhileDragging && (this.clipping == UIDrawCall.Clipping.None || this.mCullTime > this.mUpdateTime);
int j = 0;
int size2 = this.mWidgets.size;
while (j < size2)
{
UIWidget uiwidget = this.mWidgets[j];
if (uiwidget.UpdateGeometry(this, forceVisible) && !this.mChanged.Contains(uiwidget.material))
{
this.mChanged.Add(uiwidget.material);
}
j++;
}
if (this.mChanged.size != 0 && this.onChange != null)
{
this.onChange();
}
if (this.mDepthChanged)
{
this.mDepthChanged = false;
this.mWidgets.Sort(new Comparison <UIWidget>(UIWidget.CompareFunc));
}
int k = 0;
int size3 = this.mChanged.size;
while (k < size3)
{
this.Fill(this.mChanged.buffer[k]);
k++;
}
this.UpdateDrawcalls();
this.mChanged.Clear();
}
private void LateUpdate()
{
this.mUpdateTime = Time.realtimeSinceStartup;
this.UpdateTransformMatrix();
if (this.mLayer != this.cachedGameObject.layer)
{
this.mLayer = this.mGo.layer;
UICamera camera = UICamera.FindCameraForLayer(this.mLayer);
this.mCam = (camera == null) ? NGUITools.FindCameraForLayer(this.mLayer) : camera.cachedCamera;
SetChildLayer(this.cachedTransform, this.mLayer);
int num = 0;
int num2 = this.drawCalls.size;
while (num < num2)
{
this.mDrawCalls.buffer[num].gameObject.layer = this.mLayer;
num++;
}
}
bool forceVisible = !this.cullWhileDragging ? ((this.clipping == UIDrawCall.Clipping.None) || (this.mCullTime > this.mUpdateTime)) : false;
int num3 = 0;
int size = this.mWidgets.size;
while (num3 < size)
{
UIWidget widget = this.mWidgets[num3];
if (widget.UpdateGeometry(this, forceVisible) && !this.mChanged.Contains(widget.material))
{
this.mChanged.Add(widget.material);
}
num3++;
}
if ((this.mChanged.size != 0) && (this.onChange != null))
{
this.onChange();
}
if (this.mDepthChanged)
{
this.mDepthChanged = false;
this.mWidgets.Sort(new Comparison <UIWidget>(UIWidget.CompareFunc));
}
int index = 0;
int num6 = this.mChanged.size;
while (index < num6)
{
this.Fill(this.mChanged.buffer[index]);
index++;
}
this.UpdateDrawcalls();
this.mChanged.Clear();
}
private void UpdateWidgets()
{
bool flag = !this.cullWhileDragging && this.mCullTime > this.mUpdateTime;
bool flag2 = false;
if (this.mForced != flag)
{
this.mForced = flag;
this.mResized = true;
}
bool clipsChildren = this.clipsChildren;
int i = 0;
int size = this.widgets.size;
while (i < size)
{
UIWidget uIWidget = this.widgets.buffer[i];
if (uIWidget.panel == this && uIWidget.enabled)
{
int frameCount = Time.frameCount;
if (uIWidget.UpdateTransform(frameCount) || this.mResized)
{
bool visibleByAlpha = flag || uIWidget.CalculateCumulativeAlpha(frameCount) > 0.001f;
uIWidget.UpdateVisibility(visibleByAlpha, flag || (!clipsChildren && !uIWidget.hideIfOffScreen) || this.IsVisible(uIWidget));
}
if (uIWidget.UpdateGeometry(frameCount))
{
flag2 = true;
if (!this.mRebuild)
{
if (uIWidget.drawCall != null)
{
uIWidget.drawCall.isDirty = true;
}
else
{
this.FindDrawCall(uIWidget);
}
}
}
}
i++;
}
if (flag2 && this.onGeometryUpdated != null)
{
this.onGeometryUpdated();
}
this.mResized = false;
}
private void UpdateWidgets()
{
bool flag = !cullWhileDragging && mCullTime > mUpdateTime;
bool flag2 = false;
if (mForced != flag)
{
mForced = flag;
mResized = true;
}
bool hasCumulativeClipping = this.hasCumulativeClipping;
int i = 0;
for (int count = widgets.Count; i < count; i++)
{
UIWidget uIWidget = widgets[i];
if (!(uIWidget.panel == this) || !uIWidget.enabled)
{
continue;
}
int frameCount = Time.frameCount;
if (uIWidget.UpdateTransform(frameCount) || mResized)
{
bool visibleByAlpha = flag || uIWidget.CalculateCumulativeAlpha(frameCount) > 0.001f;
uIWidget.UpdateVisibility(visibleByAlpha, flag || (!hasCumulativeClipping && !uIWidget.hideIfOffScreen) || IsVisible(uIWidget));
}
if (!uIWidget.UpdateGeometry(frameCount))
{
continue;
}
flag2 = true;
if (!mRebuild)
{
if (uIWidget.drawCall != null)
{
uIWidget.drawCall.isDirty = true;
}
else
{
FindDrawCall(uIWidget);
}
}
}
if (flag2 && onGeometryUpdated != null)
{
onGeometryUpdated();
}
mResized = false;
}
/// <summary>
/// Update all widgets and rebuild their geometry if necessary.
/// </summary>
public void UpdateWidgets()
{
var child = mWidgetDicts.Values.GetEnumerator();
while (child.MoveNext() == true)
{
UIWidget w = child.Current;
// If the widget is visible, update it
if (w.visibleFlag == 1 && w != null && w.UpdateGeometry(ref mWorldToLocal, (w.changeFlag == 1)))
{
mtlChanged = true;
}
}
}
static public int UpdateGeometry(IntPtr l)
{
try {
UIWidget self = (UIWidget)checkSelf(l);
System.Int32 a1;
checkType(l, 2, out a1);
var ret = self.UpdateGeometry(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static int UpdateGeometry(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 2);
UIWidget obj = (UIWidget)ToLua.CheckObject<UIWidget>(L, 1);
int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
bool o = obj.UpdateGeometry(arg0);
LuaDLL.lua_pushboolean(L, o);
return 1;
}
catch (Exception e)
{
return LuaDLL.toluaL_exception(L, e);
}
}
private void LateUpdate()
{
mUpdateTime = Time.realtimeSinceStartup;
UpdateTransformMatrix();
if (mLayer != cachedGameObject.layer)
{
mLayer = mGo.layer;
UICamera uICamera = UICamera.FindCameraForLayer(mLayer);
mCam = uICamera == null?NGUITools.FindCameraForLayer(mLayer) : uICamera.cachedCamera;
SetChildLayer(cachedTransform, mLayer);
int i = 0;
for (int size = drawCalls.size; i < size; i++)
{
mDrawCalls.buffer[i].gameObject.layer = mLayer;
}
}
bool forceVisible = !cullWhileDragging && (clipping == UIDrawCall.Clipping.None || mCullTime > mUpdateTime);
int j = 0;
for (int size2 = mWidgets.size; j < size2; j++)
{
UIWidget uIWidget = mWidgets[j];
if (uIWidget.UpdateGeometry(this, forceVisible) && !mChanged.Contains(uIWidget.material))
{
mChanged.Add(uIWidget.material);
}
}
if (mChanged.size != 0 && onChange != null)
{
onChange();
}
if (mDepthChanged)
{
mDepthChanged = false;
mWidgets.Sort(UIWidget.CompareFunc);
}
int k = 0;
for (int size3 = mChanged.size; k < size3; k++)
{
Fill(mChanged.buffer[k]);
}
UpdateDrawcalls();
mChanged.Clear();
}
private void UpdateWidgets()
{
int num = 0;
int count = this.mChildren.Count;
while (num < count)
{
UINode item = (UINode)this.mChildren[num];
UIWidget uIWidget = item.widget;
if (item.visibleFlag == 1 && uIWidget != null && uIWidget.UpdateGeometry(ref this.mWorldToLocal, item.changeFlag == 1, this.generateNormals) && !this.mChanged.Contains(uIWidget.material))
{
this.mChanged.Add(uIWidget.material);
this.mChangedLastFrame = true;
}
item.changeFlag = 0;
num++;
}
}
/// <summary>
/// Update all widgets and rebuild their geometry if necessary.
/// </summary>
void UpdateWidgets()
{
foreach (KeyValuePair <Transform, UINode> c in mChildren)
{
UINode pc = c.Value;
UIWidget w = pc.widget;
// If the widget is visible, update it
if (pc.visibleFlag == 1 && w != null && w.UpdateGeometry(ref mWorldToLocal, (pc.changeFlag == 1), generateNormals))
{
// We will need to refill this buffer
if (!mChanged.Contains(w.material))
{
mChanged.Add(w.material);
}
}
}
}
private void UpdateWidgets()
{
int num = 0;
int count = this.mChildren.Count;
while (num < count)
{
UINode node = (UINode)this.mChildren[num];
UIWidget widget = node.widget;
if (((node.visibleFlag == 1) && (widget != null)) && (widget.UpdateGeometry(ref this.mWorldToLocal, node.changeFlag == 1, this.generateNormals) && !this.mChanged.Contains(widget.material)))
{
this.mChanged.Add(widget.material);
this.mChangedLastFrame = true;
}
node.changeFlag = 0;
num++;
}
}
/// <summary>
/// Update all of the widgets belonging to this panel.
/// </summary>
void UpdateWidgets()
{
#if UNITY_EDITOR
bool forceVisible = cullWhileDragging ? false : (clipping == UIDrawCall.Clipping.None) || (Application.isPlaying && mCullTime > mUpdateTime);
#else
bool forceVisible = cullWhileDragging ? false : (clipping == UIDrawCall.Clipping.None) || (mCullTime > mUpdateTime);
#endif
bool changed = false;
// Update all widgets
for (int i = 0, imax = UIWidget.list.size; i < imax; ++i)
{
UIWidget w = UIWidget.list[i];
// If the widget is visible, update it
if (w.enabled && w.panel == this && w.UpdateGeometry(this, forceVisible))
{
changed = true;
if (mFullRebuild)
{
continue;
}
int index = w.renderQueue;
if (index < 0)
{
mFullRebuild = true;
}
else if (index < UIDrawCall.list.size && UIDrawCall.list[index] != null)
{
UIDrawCall.list[index].isDirty = true;
}
}
}
// Inform the changed event listeners
if (changed && onChange != null)
{
onChange();
}
}
private void UpdateWidgets()
{
Boolean flag = false;
Boolean flag2 = false;
Boolean hasCumulativeClipping = this.hasCumulativeClipping;
if (!this.cullWhileDragging)
{
for (Int32 i = 0; i < UIScrollView.list.size; i++)
{
UIScrollView uiscrollView = UIScrollView.list[i];
if (uiscrollView.panel == this && uiscrollView.isDragging)
{
flag2 = true;
}
}
}
if (this.mForced != flag2)
{
this.mForced = flag2;
this.mResized = true;
}
Int32 frameCount = Time.frameCount;
Int32 j = 0;
Int32 count = this.widgets.Count;
while (j < count)
{
UIWidget uiwidget = (UIWidget)null;
try
{
uiwidget = this.widgets[j];
}
catch
{
goto IL_183;
}
goto IL_B6;
IL_183:
j++;
continue;
IL_B6:
if (!(uiwidget.panel == this) || !uiwidget.enabled)
{
goto IL_183;
}
if (uiwidget.UpdateTransform(frameCount) || this.mResized)
{
Boolean visibleByAlpha = flag2 || uiwidget.CalculateCumulativeAlpha(frameCount) > 0.001f;
uiwidget.UpdateVisibility(visibleByAlpha, flag2 || (!hasCumulativeClipping && !uiwidget.hideIfOffScreen) || this.IsVisible(uiwidget));
}
if (!uiwidget.UpdateGeometry(frameCount))
{
goto IL_183;
}
flag = true;
if (this.mRebuild)
{
goto IL_183;
}
if (uiwidget.drawCall != (UnityEngine.Object)null)
{
uiwidget.drawCall.isDirty = true;
goto IL_183;
}
this.FindDrawCall(uiwidget);
goto IL_183;
}
if (flag && this.onGeometryUpdated != null)
{
this.onGeometryUpdated();
}
this.mResized = false;
}
/// <summary>
/// Convenience function that figures out the panel's correct change flag by searching the parents.
/// </summary>
int GetChangeFlag(UINode start)
{
int flag = start.changeFlag;
if (flag == -1)
{
Transform trans = start.trans.parent;
UINode sub;
// Keep going until we find a set flag
for (;;)
{
// Check the parent's flag
#if USE_SIMPLE_DICTIONARY
if (trans != null && mChildren.TryGetValue(trans, out sub))
{
#else
if (trans != null && mChildren.Contains(trans))
{
sub = (UINode)mChildren[trans];
#endif
flag = sub.changeFlag;
trans = trans.parent;
// If the flag hasn't been set either, add this child to the hierarchy
if (flag == -1)
{
mHierarchy.Add(sub);
}
else
{
break;
}
}
else
{
flag = 0;
break;
}
}
// Update the parent flags
for (int i = 0, imax = mHierarchy.size; i < imax; ++i)
{
UINode pc = mHierarchy.buffer[i];
pc.changeFlag = flag;
}
mHierarchy.Clear();
}
return(flag);
}
/// <summary>
/// Update the world-to-local transform matrix as well as clipping bounds.
/// </summary>
void UpdateTransformMatrix()
{
if (mUpdateTime == 0f || mMatrixTime != mUpdateTime)
{
mMatrixTime = mUpdateTime;
mWorldToLocal = cachedTransform.worldToLocalMatrix;
if (mClipping != UIDrawCall.Clipping.None)
{
Vector2 size = new Vector2(mClipRange.z, mClipRange.w);
if (size.x == 0f)
{
size.x = (mCam == null) ? Screen.width : mCam.pixelWidth;
}
if (size.y == 0f)
{
size.y = (mCam == null) ? Screen.height : mCam.pixelHeight;
}
size *= 0.5f;
mMin.x = mClipRange.x - size.x;
mMin.y = mClipRange.y - size.y;
mMax.x = mClipRange.x + size.x;
mMax.y = mClipRange.y + size.y;
}
}
}
/// <summary>
/// Run through all managed transforms and see if they've changed.
/// </summary>
void UpdateTransforms()
{
mChangedLastFrame = false;
bool transformsChanged = false;
bool shouldCull = false;
#if UNITY_EDITOR
shouldCull = (clipping != UIDrawCall.Clipping.None) && (!Application.isPlaying || mUpdateTime > mCullTime);
if (!Application.isPlaying || !widgetsAreStatic || mWidgetsAdded || shouldCull != mCulled)
#else
shouldCull = (clipping != UIDrawCall.Clipping.None) && (mUpdateTime > mCullTime);
if (!widgetsAreStatic || mWidgetsAdded || shouldCull != mCulled)
#endif
{
#if USE_SIMPLE_DICTIONARY
foreach (KeyValuePair <Transform, UINode> child in mChildren)
{
UINode node = child.Value;
#else
for (int i = 0, imax = mChildren.Count; i < imax; ++i)
{
UINode node = (UINode)mChildren[i];
#endif
if (node.trans == null)
{
mRemoved.Add(node.trans);
continue;
}
if (node.HasChanged())
{
node.changeFlag = 1;
transformsChanged = true;
#if UNITY_EDITOR
Vector3 s = node.trans.lossyScale;
float min = Mathf.Abs(Mathf.Min(s.x, s.y));
if (min == 0f)
{
Debug.LogError("Scale of 0 is invalid! Zero cannot be divided by, which causes problems. Use a small value instead, such as 0.01\n" +
node.trans.lossyScale, node.trans);
}
#endif
}
else
{
node.changeFlag = -1;
}
}
// Clean up the deleted transforms
for (int i = 0, imax = mRemoved.Count; i < imax; ++i)
{
mChildren.Remove(mRemoved[i]);
}
mRemoved.Clear();
}
// If the children weren't culled but should be, check their visibility
if (!mCulled && shouldCull)
{
mCheckVisibility = true;
}
// If something has changed, propagate the changes *down* the tree hierarchy (to children).
// An alternative (but slower) approach would be to do a pc.trans.GetComponentsInChildren<UIWidget>()
// in the loop above, and mark each one as dirty.
if (mCheckVisibility || transformsChanged || mRebuildAll)
{
#if USE_SIMPLE_DICTIONARY
foreach (KeyValuePair <Transform, UINode> child in mChildren)
{
UINode pc = child.Value;
#else
for (int i = 0, imax = mChildren.Count; i < imax; ++i)
{
UINode pc = (UINode)mChildren[i];
#endif
if (pc.widget != null)
{
int visibleFlag = 1;
// No sense in checking the visibility if we're not culling anything (as the visibility is always 'true')
if (shouldCull || transformsChanged)
{
// If the change flag has not yet been determined...
if (pc.changeFlag == -1)
{
pc.changeFlag = GetChangeFlag(pc);
}
// Is the widget visible?
if (shouldCull)
{
visibleFlag = (mCheckVisibility || pc.changeFlag == 1) ? (IsVisible(pc.widget) ? 1 : 0) : pc.visibleFlag;
}
}
// If visibility changed, mark the node as changed as well
if (pc.visibleFlag != visibleFlag)
{
pc.changeFlag = 1;
}
// If the node has changed and the widget is visible (or was visible before)
if (pc.changeFlag == 1 && (visibleFlag == 1 || pc.visibleFlag != 0))
{
// Update the visibility flag
pc.visibleFlag = visibleFlag;
Material mat = pc.widget.material;
// Add this material to the list of changed materials
if (!mChanged.Contains(mat))
{
mChanged.Add(mat);
mChangedLastFrame = true;
}
}
}
}
}
mCulled = shouldCull;
mCheckVisibility = false;
mWidgetsAdded = false;
}
/// <summary>
/// Update all widgets and rebuild their geometry if necessary.
/// </summary>
void UpdateWidgets()
{
#if USE_SIMPLE_DICTIONARY
foreach (KeyValuePair <Transform, UINode> c in mChildren)
{
UINode pc = c.Value;
#else
for (int i = 0, imax = mChildren.Count; i < imax; ++i)
{
UINode pc = (UINode)mChildren[i];
#endif
UIWidget w = pc.widget;
// If the widget is visible, update it
if (pc.visibleFlag == 1 && w != null && w.UpdateGeometry(ref mWorldToLocal, (pc.changeFlag == 1), generateNormals))
{
// We will need to refill this buffer
if (!mChanged.Contains(w.material))
{
mChanged.Add(w.material);
mChangedLastFrame = true;
}
}
pc.changeFlag = 0;
}
}
/// <summary>
/// Update the clipping rect in the shaders and draw calls' positions.
/// </summary>
bool nestingClip = false;
Vector4 newClipRange = Vector4.zero;
public void UpdateDrawcalls()
{
Vector4 range = Vector4.zero;
if (mClipping != UIDrawCall.Clipping.None)
{
UIDraggablePanel dragPanel = gameObject.GetComponent <UIDraggablePanel>();
if (dragPanel != null && gameObject.transform.parent != null)
{
UIPanel parentPanel = NGUITools.FindInParents <UIPanel>(gameObject.transform.parent.gameObject);
if (parentPanel != null && parentPanel.transform.parent != null && parentPanel.clipping != UIDrawCall.Clipping.None)
{
Vector3 worldPos = transform.TransformPoint(Vector3.zero);
Vector3 localPos = parentPanel.transform.parent.InverseTransformPoint(worldPos);
newClipRange = mClipRange;
Vector4 parentRect = new Vector4(-localPos.x - parentPanel.clipRange.z / 2
, -localPos.y - parentPanel.clipRange.w / 2
, -localPos.x + parentPanel.clipRange.z / 2
, -localPos.y + parentPanel.clipRange.w / 2);
Vector4 selfRect = new Vector4(newClipRange.x - newClipRange.z / 2
, newClipRange.y - newClipRange.w / 2
, newClipRange.x + newClipRange.z / 2
, newClipRange.y + newClipRange.w / 2
);
if (selfRect.x < parentRect.x)
{
selfRect.x = parentRect.x;
nestingClip = true;
}
if (selfRect.y < parentRect.y)
{
selfRect.y = parentRect.y;
nestingClip = true;
}
if (selfRect.z > parentRect.z)
{
selfRect.z = parentRect.z;
nestingClip = true;
}
if (selfRect.w > parentRect.w)
{
selfRect.w = parentRect.w;
nestingClip = true;
}
float xLength = selfRect.z - selfRect.x;
if (xLength < 0)
{
xLength = 0.0001f;
}
float yLength = selfRect.w - selfRect.y;
if (yLength < 0)
{
yLength = 0.0001f;
}
newClipRange = new Vector4(selfRect.x + xLength / 2
, selfRect.y + yLength / 2
, xLength
, yLength);
//if (newClipRange.x < -localPos.x - Mathf.Abs(parentPanel.clipRange.z - newClipRange.z)/2)
//{
// float offset = -localPos.x - Mathf.Abs(parentPanel.clipRange.z - newClipRange.z)/2;
// newClipRange.x = offset / 2;
// newClipRange.z -= offset;
// nestingClip = true;
//}
//else if (newClipRange.x > -localPos.x + Mathf.Abs(parentPanel.clipRange.z - newClipRange.z)/2)
//{
// float offset = localPos.x + Mathf.Abs(parentPanel.clipRange.z - newClipRange.z)/2;
// newClipRange.x -= offset / 2;
// newClipRange.z = offset;
// nestingClip = true;
//}
//else
//{
// nestingClip = false;
//}
//if (newClipRange.y < -localPos.y)
//{
// newClipRange.y = -localPos.y;
// newClipRange.w = parentPanel.clipRange.w;
//}
}
}
if (nestingClip)
{
range = new Vector4(newClipRange.x, newClipRange.y, newClipRange.z * 0.5f, newClipRange.w * 0.5f);
}
else
{
range = new Vector4(mClipRange.x, mClipRange.y, mClipRange.z * 0.5f, mClipRange.w * 0.5f);
}
}
if (range.z == 0f)
{
range.z = Screen.width * 0.5f;
}
if (range.w == 0f)
{
range.w = Screen.height * 0.5f;
}
RuntimePlatform platform = Application.platform;
if (platform == RuntimePlatform.WindowsPlayer ||
platform == RuntimePlatform.WindowsWebPlayer ||
platform == RuntimePlatform.WindowsEditor)
{
range.x -= 0.5f;
range.y += 0.5f;
}
Transform t = cachedTransform;
for (int i = 0, imax = mDrawCalls.size; i < imax; ++i)
{
UIDrawCall dc = mDrawCalls.buffer[i];
dc.clipping = mClipping;
dc.clipRange = range;
dc.clipSoftness = mClipSoftness;
dc.depthPass = depthPass;
// Set the draw call's transform to match the panel's.
// Note that parenting directly to the panel causes unity to crash as soon as you hit Play.
Transform dt = dc.transform;
dt.position = t.position;
dt.rotation = t.rotation;
dt.localScale = t.lossyScale;
}
}
/// <summary>
/// Set the draw call's geometry responsible for the specified material.
/// </summary>
void Fill(Material mat)
{
// Cleanup deleted widgets
for (int i = mWidgets.size; i > 0;)
{
if (mWidgets[--i] == null)
{
mWidgets.RemoveAt(i);
}
}
// Fill the buffers for the specified material
for (int i = 0, imax = mWidgets.size; i < imax; ++i)
{
UIWidget w = mWidgets.buffer[i];
if (w.visibleFlag == 1 && w.material == mat)
{
UINode node = GetNode(w.cachedTransform);
if (node != null)
{
if (generateNormals)
{
w.WriteToBuffers(mVerts, mUvs, mCols, mNorms, mTans);
}
else
{
w.WriteToBuffers(mVerts, mUvs, mCols, null, null);
}
}
else
{
Debug.LogError("No transform found for " + NGUITools.GetHierarchy(w.gameObject), this);
}
}
}
if (mVerts.size > 0)
{
// Rebuild the draw call's mesh
UIDrawCall dc = GetDrawCall(mat, true);
dc.depthPass = depthPass;
dc.Set(mVerts, generateNormals ? mNorms : null, generateNormals ? mTans : null, mUvs, mCols);
}
else
{
// There is nothing to draw for this material -- eliminate the draw call
UIDrawCall dc = GetDrawCall(mat, false);
if (dc != null)
{
mDrawCalls.Remove(dc);
NGUITools.DestroyImmediate(dc.gameObject);
}
}
// Cleanup
mVerts.Clear();
mNorms.Clear();
mTans.Clear();
mUvs.Clear();
mCols.Clear();
}
/// <summary>
/// Update all of the widgets belonging to this panel.
/// </summary>
void UpdateWidgets()
{
#if UNITY_EDITOR
bool forceVisible = cullWhileDragging ? false : (Application.isPlaying && mCullTime > mUpdateTime);
#else
bool forceVisible = cullWhileDragging ? false : (mCullTime > mUpdateTime);
#endif
bool changed = false;
// Update all widgets
for (int i = 0, imax = UIWidget.list.size; i < imax; ++i)
{
UIWidget w = UIWidget.list[i];
// If the widget is visible, update it
if (w.panel == this && w.enabled)
{
#if UNITY_EDITOR
// When an object is dragged from Project view to Scene view, its Z is...
// odd, to say the least. Force it if possible.
if (!Application.isPlaying)
{
Transform t = w.cachedTransform;
if (t.hideFlags != HideFlags.HideInHierarchy)
{
t = (t.parent != null && t.parent.hideFlags == HideFlags.HideInHierarchy) ?
t.parent : null;
}
if (t != null)
{
for (; ;)
{
if (t.parent == null)
{
break;
}
if (t.parent.hideFlags == HideFlags.HideInHierarchy)
{
t = t.parent;
}
else
{
break;
}
}
if (t != null)
{
Vector3 pos = t.localPosition;
pos.x = Mathf.Round(pos.x);
pos.y = Mathf.Round(pos.y);
pos.z = 0f;
if (Vector3.SqrMagnitude(t.localPosition - pos) > 0.0001f)
{
t.localPosition = pos;
}
}
}
}
#endif
bool vis = forceVisible ||
(mClipping == UIDrawCall.Clipping.None && !w.hideIfOffScreen) ||
(w.cumulativeAlpha > 0.001f && IsVisible(w));
if (!w.UpdateGeometry(vis))
{
continue;
}
changed = true;
if (!mRebuild)
{
if (w.drawCall != null)
{
w.drawCall.isDirty = true;
}
else
{
// Find an existing draw call, if possible
w.drawCall = InsertWidget(w);
if (w.drawCall == null)
{
mRebuild = true;
}
}
}
}
}
// Inform the changed event listeners
if (changed && onChange != null)
{
onChange();
}
}
/// <summary>
/// Convenience function that figures out the panel's correct change flag by searching the parents.
/// </summary>
int GetChangeFlag(UINode start)
{
int flag = start.changeFlag;
if (flag == -1)
{
Transform trans = start.trans.parent;
UINode sub;
// Keep going until we find a set flag
for (;;)
{
// Check the parent's flag
#if USE_SIMPLE_DICTIONARY
if (trans != null && mChildren.TryGetValue(trans, out sub))
{
#else
if (trans != null && mChildren.Contains(trans))
{
sub = (UINode)mChildren[trans];
#endif
flag = sub.changeFlag;
trans = trans.parent;
// If the flag hasn't been set either, add this child to the hierarchy
if (flag == -1)
{
mHierarchy.Add(sub);
}
else
{
break;
}
}
else
{
flag = 0;
break;
}
}
// Update the parent flags
for (int i = 0, imax = mHierarchy.size; i < imax; ++i)
{
UINode pc = mHierarchy.buffer[i];
pc.changeFlag = flag;
}
mHierarchy.Clear();
}
return(flag);
}
/// <summary>
/// Run through all managed transforms and see if they've changed.
/// </summary>
void UpdateTransforms()
{
bool transformsChanged = false;
bool shouldCull = false;
#if UNITY_EDITOR
shouldCull = (clipping != UIDrawCall.Clipping.None) && (!Application.isPlaying || (cullWhileDragging || mUpdateTime > mCullTime));
if (!Application.isPlaying || !widgetsAreStatic || mWidgetsAdded || shouldCull != mCulled)
#else
shouldCull = (clipping != UIDrawCall.Clipping.None) && (mUpdateTime > mCullTime);
if (!widgetsAreStatic || mWidgetsAdded || shouldCull != mCulled)
#endif
{
#if USE_SIMPLE_DICTIONARY
foreach (KeyValuePair <Transform, UINode> child in mChildren)
{
UINode node = child.Value;
#else
for (int i = 0, imax = mChildren.Count; i < imax; ++i)
{
UINode node = (UINode)mChildren[i];
#endif
if (node.trans == null)
{
mRemoved.Add(node.trans);
continue;
}
if (node.HasChanged())
{
node.changeFlag = 1;
transformsChanged = true;
#if UNITY_EDITOR
Vector3 s = node.trans.lossyScale;
float min = Mathf.Abs(Mathf.Min(s.x, s.y));
if (min == 0f)
{
Debug.LogError("Scale of 0 is invalid! Zero cannot be divided by, which causes problems. Use a small value instead, such as 0.01\n" +
node.trans.lossyScale, node.trans);
}
#endif
}
else
{
node.changeFlag = -1;
}
}
// Clean up the deleted transforms
for (int i = 0, imax = mRemoved.Count; i < imax; ++i)
{
mChildren.Remove(mRemoved[i]);
}
mRemoved.Clear();
}
// If the children weren't culled but should be, check their visibility
if (!mCulled && shouldCull)
{
mCheckVisibility = true;
}
// If something has changed, propagate the changes *down* the tree hierarchy (to children).
// An alternative (but slower) approach would be to do a pc.trans.GetComponentsInChildren<UIWidget>()
// in the loop above, and mark each one as dirty.
if (mCheckVisibility || transformsChanged || mRebuildAll)
{
#if USE_SIMPLE_DICTIONARY
foreach (KeyValuePair <Transform, UINode> child in mChildren)
{
UINode pc = child.Value;
#else
for (int i = 0, imax = mChildren.Count; i < imax; ++i)
{
UINode pc = (UINode)mChildren[i];
#endif
if (pc.widget != null)
{
int visibleFlag = 1;
// No sense in checking the visibility if we're not culling anything (as the visibility is always 'true')
if (shouldCull || transformsChanged)
{
// If the change flag has not yet been determined...
if (pc.changeFlag == -1)
{
pc.changeFlag = GetChangeFlag(pc);
}
// Is the widget visible?
if (shouldCull)
{
visibleFlag = (mCheckVisibility || pc.changeFlag == 1) ? (IsVisible(pc.widget) ? 1 : 0) : pc.visibleFlag;
}
}
// If visibility changed, mark the node as changed as well
if (pc.visibleFlag != visibleFlag)
{
pc.changeFlag = 1;
}
// If the node has changed and the widget is visible (or was visible before)
if (pc.changeFlag == 1 && (visibleFlag == 1 || pc.visibleFlag != 0))
{
// Update the visibility flag
pc.visibleFlag = visibleFlag;
Material mat = pc.widget.material;
// Add this material to the list of changed materials
if (!mChanged.Contains(mat))
{
mChanged.Add(mat);
}
}
}
}
}
mCulled = shouldCull;
mCheckVisibility = false;
mWidgetsAdded = false;
}
/// <summary>
/// Update all widgets and rebuild their geometry if necessary.
/// </summary>
void UpdateWidgets()
{
#if USE_SIMPLE_DICTIONARY
foreach (KeyValuePair <Transform, UINode> c in mChildren)
{
UINode pc = c.Value;
#else
for (int i = 0, imax = mChildren.Count; i < imax; ++i)
{
UINode pc = (UINode)mChildren[i];
#endif
UIWidget w = pc.widget;
// If the widget is visible, update it
if (pc.visibleFlag == 1 && w != null && w.UpdateGeometry(this, ref worldToLocal, (pc.changeFlag == 1), generateNormals))
{
// We will need to refill this buffer
if (!mChanged.Contains(w.material))
{
mChanged.Add(w.material);
}
}
pc.changeFlag = 0;
}
}
#endif
/// <summary>
/// Update the clipping rect in the shaders and draw calls' positions.
/// </summary>
public void UpdateDrawcalls()
{
Vector4 range = Vector4.zero;
if (mClipping != UIDrawCall.Clipping.None)
{
range = new Vector4(mClipRange.x, mClipRange.y, mClipRange.z * 0.5f, mClipRange.w * 0.5f);
}
if (range.z == 0f)
{
range.z = Screen.width * 0.5f;
}
if (range.w == 0f)
{
range.w = Screen.height * 0.5f;
}
RuntimePlatform platform = Application.platform;
if (platform == RuntimePlatform.WindowsPlayer ||
platform == RuntimePlatform.WindowsWebPlayer ||
platform == RuntimePlatform.WindowsEditor)
{
range.x -= 0.5f;
range.y += 0.5f;
}
Transform t = cachedTransform;
UIDrawCall dc;
Transform dt;
for (int i = 0, imax = mDrawCalls.size; i < imax; ++i)
{
dc = mDrawCalls.buffer[i];
dc.clipping = mClipping;
dc.clipRange = range;
dc.clipSoftness = mClipSoftness;
dc.depthPass = depthPass && mClipping == UIDrawCall.Clipping.None;
// Set the draw call's transform to match the panel's.
// Note that parenting directly to the panel causes unity to crash as soon as you hit Play.
dt = dc.transform;
dt.position = t.position;
dt.rotation = t.rotation;
dt.localScale = t.lossyScale;
}
}
/// <summary>
/// Set the draw call's geometry responsible for the specified material.
/// </summary>
void Fill(Material mat)
{
int highest = -100;
// Fill the buffers for the specified material
for (int i = 0; i < mWidgets.size;)
{
UIWidget w = mWidgets.buffer[i];
if (w == null)
{
mWidgets.RemoveAt(i);
continue;
}
#if OLD_UNITY
else if (w.visibleFlag == 1 && w.material == mat)
#else
else if (w.material == mat && w.isVisible)
#endif
{
if (w.panel == this)
{
int depth = w.depth;
if (depth > highest)
{
highest = depth;
}
if (generateNormals)
{
w.WriteToBuffers(mVerts, mUvs, mCols, mNorms, mTans);
}
else
{
w.WriteToBuffers(mVerts, mUvs, mCols, null, null);
}
}
else
{
mWidgets.RemoveAt(i);
continue;
}
}
++i;
}
if (mVerts.size > 0)
{
// Rebuild the draw call's mesh
UIDrawCall dc = GetDrawCall(mat, true);
dc.depthPass = depthPass && mClipping == UIDrawCall.Clipping.None;
dc.depth = sortByDepth ? highest : 0;
dc.Set(mVerts, generateNormals ? mNorms : null, generateNormals ? mTans : null, mUvs, mCols);
dc.mainTexture = mat.mainTexture;
}
else
{
// There is nothing to draw for this material -- eliminate the draw call
UIDrawCall dc = GetDrawCall(mat, false);
if (dc != null)
{
mDrawCalls.Remove(dc);
NGUITools.DestroyImmediate(dc.gameObject);
}
}
// Cleanup
mVerts.Clear();
mNorms.Clear();
mTans.Clear();
mUvs.Clear();
mCols.Clear();
}
/// <summary>
/// Main update function
/// </summary>
void LateUpdate()
{
mUpdateTime = Time.realtimeSinceStartup;
UpdateTransformMatrix();
#if OLD_UNITY
UpdateTransforms();
#endif
// Always move widgets to the panel's layer
if (mLayer != cachedGameObject.layer)
{
mLayer = mGo.layer;
UICamera uic = UICamera.FindCameraForLayer(mLayer);
mCam = (uic != null) ? uic.cachedCamera : NGUITools.FindCameraForLayer(mLayer);
SetChildLayer(cachedTransform, mLayer);
for (int i = 0, imax = drawCalls.size; i < imax; ++i)
{
mDrawCalls.buffer[i].gameObject.layer = mLayer;
}
}
#if OLD_UNITY
UpdateWidgets();
#else
#if UNITY_EDITOR
bool forceVisible = cullWhileDragging ? false : (clipping == UIDrawCall.Clipping.None) || (Application.isPlaying && mCullTime > mUpdateTime);
#else
bool forceVisible = cullWhileDragging ? false : (clipping == UIDrawCall.Clipping.None) || (mCullTime > mUpdateTime);
#endif
// Update all widgets
for (int i = 0, imax = mWidgets.size; i < imax; ++i)
{
UIWidget w = mWidgets[i];
// If the widget is visible, update it
if (w.UpdateGeometry(this, forceVisible))
{
// We will need to refill this buffer
if (!mChanged.Contains(w.material))
{
mChanged.Add(w.material);
}
}
}
#endif
// Inform the changed event listeners
if (mChanged.size != 0 && onChange != null)
{
onChange();
}
// If the depth has changed, we need to re-sort the widgets
if (mDepthChanged)
{
mDepthChanged = false;
mWidgets.Sort(UIWidget.CompareFunc);
}
// Fill the draw calls for all of the changed materials
for (int i = 0, imax = mChanged.size; i < imax; ++i)
{
Fill(mChanged.buffer[i]);
}
// Update the clipping rects
UpdateDrawcalls();
mChanged.Clear();
#if OLD_UNITY
mRebuildAll = false;
#endif
#if UNITY_EDITOR
mScreenSize = new Vector2(Screen.width, Screen.height);
#endif
}
/// <summary>
/// Update all of the widgets belonging to this panel.
/// </summary>
void UpdateWidgets()
{
#if UNITY_EDITOR
bool forceVisible = cullWhileDragging ? false : (Application.isPlaying && mCullTime > mUpdateTime);
#else
bool forceVisible = cullWhileDragging ? false : (mCullTime > mUpdateTime);
#endif
bool changed = false;
if (mForced != forceVisible)
{
mForced = forceVisible;
mResized = true;
}
bool clipped = hasCumulativeClipping;
// Update all widgets
for (int i = 0, imax = widgets.Count; i < imax; ++i)
{
UIWidget w = widgets[i];
// If the widget is visible, update it
if (w.panel == this && w.enabled)
{
#if UNITY_EDITOR
// When an object is dragged from Project view to Scene view, its Z is...
// odd, to say the least. Force it if possible.
if (!Application.isPlaying)
{
Transform t = w.cachedTransform;
if (t.hideFlags != HideFlags.HideInHierarchy)
{
t = (t.parent != null && t.parent.hideFlags == HideFlags.HideInHierarchy) ?
t.parent : null;
}
if (t != null)
{
for (; ; )
{
if (t.parent == null) break;
if (t.parent.hideFlags == HideFlags.HideInHierarchy) t = t.parent;
else break;
}
if (t != null)
{
Vector3 pos = t.localPosition;
pos.x = Mathf.Round(pos.x);
pos.y = Mathf.Round(pos.y);
pos.z = 0f;
if (Vector3.SqrMagnitude(t.localPosition - pos) > 0.0001f)
t.localPosition = pos;
}
}
}
#endif
int frame = Time.frameCount;
// First update the widget's transform
if (w.UpdateTransform(frame) || mResized)
{
// Only proceed to checking the widget's visibility if it actually moved
bool vis = forceVisible || (w.CalculateCumulativeAlpha(frame) > 0.001f);
w.UpdateVisibility(vis, forceVisible || ((clipped || w.hideIfOffScreen) ? IsVisible(w) : true));
}
// Update the widget's geometry if necessary
if (w.UpdateGeometry(frame))
{
changed = true;
if (!mRebuild)
{
if (w.drawCall != null)
{
w.drawCall.isDirty = true;
}
else
{
// Find an existing draw call, if possible
FindDrawCall(w);
}
}
}
}
}
// Inform the changed event listeners
if (changed && onGeometryUpdated != null) onGeometryUpdated();
mResized = false;
}
/// <summary>
/// Convenience function that figures out the panel's correct change flag by searching the parents.
/// </summary>
int GetChangeFlag(UINode start)
{
int flag = start.changeFlag;
if (flag == -1)
{
Transform trans = start.trans.parent;
UINode sub;
// Keep going until we find a set flag
for (;;)
{
// Check the parent's flag
#if UNITY_FLASH
if (trans != null && mChildren.TryGetValue(trans, out sub))
{
#else
if (trans != null && mChildren.Contains(trans))
{
sub = (UINode)mChildren[trans];
#endif
flag = sub.changeFlag;
trans = trans.parent;
// If the flag hasn't been set either, add this child to the hierarchy
if (flag == -1)
{
mHierarchy.Add(sub);
}
else
{
break;
}
}
else
{
flag = 0;
break;
}
}
// Update the parent flags
for (int i = 0, imax = mHierarchy.size; i < imax; ++i)
{
UINode pc = mHierarchy.buffer[i];
pc.changeFlag = flag;
}
mHierarchy.Clear();
}
return(flag);
}
/// <summary>
/// Update the world-to-local transform matrix as well as clipping bounds.
/// </summary>
void UpdateTransformMatrix()
{
float time = Time.realtimeSinceStartup;
if (time == 0f || mMatrixTime != time)
{
mMatrixTime = time;
mWorldToLocal = cachedTransform.worldToLocalMatrix;
if (mClipping != UIDrawCall.Clipping.None)
{
Vector2 size = new Vector2(mClipRange.z, mClipRange.w);
if (size.x == 0f)
{
size.x = mScreenSize.x;
}
if (size.y == 0f)
{
size.y = mScreenSize.y;
}
size *= 0.5f;
mMin.x = mClipRange.x - size.x;
mMin.y = mClipRange.y - size.y;
mMax.x = mClipRange.x + size.x;
mMax.y = mClipRange.y + size.y;
}
}
}
/// <summary>
/// Run through all managed transforms and see if they've changed.
/// </summary>
void UpdateTransforms()
{
mChangedLastFrame = false;
bool transformsChanged = false;
#if UNITY_EDITOR
bool shouldCull = !Application.isPlaying || Time.realtimeSinceStartup > mCullTime;
if (!Application.isPlaying || !widgetsAreStatic || mWidgetsAdded || shouldCull != mCulled)
#else
bool shouldCull = Time.realtimeSinceStartup > mCullTime;
if (!widgetsAreStatic || mWidgetsAdded || shouldCull != mCulled)
#endif
{
#if UNITY_FLASH
foreach (KeyValuePair <Transform, UINode> child in mChildren)
{
UINode node = child.Value;
#else
for (int i = 0, imax = mChildren.Count; i < imax; ++i)
{
UINode node = (UINode)mChildren[i];
#endif
if (node.trans == null)
{
mRemoved.Add(node.trans);
continue;
}
if (node.HasChanged())
{
node.changeFlag = 1;
transformsChanged = true;
}
else
{
node.changeFlag = -1;
}
}
// Clean up the deleted transforms
for (int i = 0, imax = mRemoved.Count; i < imax; ++i)
{
mChildren.Remove(mRemoved[i]);
}
mRemoved.Clear();
}
// If the children weren't culled but should be, check their visibility
if (!mCulled && shouldCull)
{
mCheckVisibility = true;
}
// If something has changed, propagate the changes *down* the tree hierarchy (to children).
// An alternative (but slower) approach would be to do a pc.trans.GetComponentsInChildren<UIWidget>()
// in the loop above, and mark each one as dirty.
if (mCheckVisibility || transformsChanged || mRebuildAll)
{
#if UNITY_FLASH
foreach (KeyValuePair <Transform, UINode> child in mChildren)
{
UINode pc = child.Value;
#else
for (int i = 0, imax = mChildren.Count; i < imax; ++i)
{
UINode pc = (UINode)mChildren[i];
#endif
if (pc.widget != null)
{
int visibleFlag = 1;
// No sense in checking the visibility if we're not culling anything (as the visibility is always 'true')
if (shouldCull || transformsChanged)
{
// If the change flag has not yet been determined...
if (pc.changeFlag == -1)
{
pc.changeFlag = GetChangeFlag(pc);
}
// Is the widget visible?
if (shouldCull)
{
visibleFlag = (mCheckVisibility || pc.changeFlag == 1) ? (IsVisible(pc.widget) ? 1 : 0) : pc.visibleFlag;
}
}
// If visibility changed, mark the node as changed as well
if (pc.visibleFlag != visibleFlag)
{
pc.changeFlag = 1;
}
// If the node has changed and the widget is visible (or was visible before)
if (pc.changeFlag == 1 && (visibleFlag == 1 || pc.visibleFlag != 0))
{
// Update the visibility flag
pc.visibleFlag = visibleFlag;
Material mat = pc.widget.material;
// Add this material to the list of changed materials
if (!mChanged.Contains(mat))
{
mChanged.Add(mat);
mChangedLastFrame = true;
}
}
}
}
}
mCulled = shouldCull;
mCheckVisibility = false;
mWidgetsAdded = false;
}
/// <summary>
/// Update all widgets and rebuild their geometry if necessary.
/// </summary>
void UpdateWidgets()
{
#if UNITY_FLASH
foreach (KeyValuePair <Transform, UINode> c in mChildren)
{
UINode pc = c.Value;
#else
for (int i = 0, imax = mChildren.Count; i < imax; ++i)
{
UINode pc = (UINode)mChildren[i];
#endif
UIWidget w = pc.widget;
// If the widget is visible, update it
if (pc.visibleFlag == 1 && w != null && w.UpdateGeometry(ref mWorldToLocal, (pc.changeFlag == 1), generateNormals))
{
// We will need to refill this buffer
if (!mChanged.Contains(w.material))
{
mChanged.Add(w.material);
mChangedLastFrame = true;
}
}
pc.changeFlag = 0;
}
}
/// <summary>
/// Update the clipping rect in the shaders and draw calls' positions.
/// </summary>
public void UpdateDrawcalls()
{
Vector4 range = Vector4.zero;
if (mClipping != UIDrawCall.Clipping.None)
{
range = new Vector4(mClipRange.x, mClipRange.y, mClipRange.z * 0.5f, mClipRange.w * 0.5f);
}
if (range.z == 0f)
{
range.z = mScreenSize.x * 0.5f;
}
if (range.w == 0f)
{
range.w = mScreenSize.y * 0.5f;
}
RuntimePlatform platform = Application.platform;
if (platform == RuntimePlatform.WindowsPlayer ||
platform == RuntimePlatform.WindowsWebPlayer ||
platform == RuntimePlatform.WindowsEditor)
{
range.x -= 0.5f;
range.y += 0.5f;
}
Transform t = cachedTransform;
for (int i = 0, imax = mDrawCalls.size; i < imax; ++i)
{
UIDrawCall dc = mDrawCalls.buffer[i];
dc.clipping = mClipping;
dc.clipRange = range;
dc.clipSoftness = mClipSoftness;
dc.depthPass = depthPass;
// Set the draw call's transform to match the panel's.
// Note that parenting directly to the panel causes unity to crash as soon as you hit Play.
Transform dt = dc.transform;
dt.position = t.position;
dt.rotation = t.rotation;
dt.localScale = t.lossyScale;
}
}
/// <summary>
/// Set the draw call's geometry responsible for the specified material.
/// </summary>
void Fill(Material mat)
{
// Cleanup deleted widgets
for (int i = mWidgets.size; i > 0;)
{
if (mWidgets[--i] == null)
{
mWidgets.RemoveAt(i);
}
}
// Fill the buffers for the specified material
for (int i = 0, imax = mWidgets.size; i < imax; ++i)
{
UIWidget w = mWidgets.buffer[i];
if (w.visibleFlag == 1 && w.material == mat)
{
UINode node = GetNode(w.cachedTransform);
if (node != null)
{
if (generateNormals)
{
w.WriteToBuffers(mVerts, mUvs, mCols, mNorms, mTans);
}
else
{
w.WriteToBuffers(mVerts, mUvs, mCols, null, null);
}
}
else
{
Debug.LogError("No transform found for " + NGUITools.GetHierarchy(w.gameObject), this);
}
}
}
if (mVerts.size > 0)
{
// Rebuild the draw call's mesh
UIDrawCall dc = GetDrawCall(mat, true);
dc.depthPass = depthPass;
dc.Set(mVerts, generateNormals ? mNorms : null, generateNormals ? mTans : null, mUvs, mCols);
}
else
{
// There is nothing to draw for this material -- eliminate the draw call
UIDrawCall dc = GetDrawCall(mat, false);
if (dc != null)
{
mDrawCalls.Remove(dc);
NGUITools.DestroyImmediate(dc.gameObject);
}
}
// Cleanup
mVerts.Clear();
mNorms.Clear();
mTans.Clear();
mUvs.Clear();
mCols.Clear();
}
/// <summary>
/// Main update function
/// </summary>
void LateUpdate()
{
UpdateTransformMatrix();
UpdateTransforms();
// Always move widgets to the panel's layer
if (mLayer != gameObject.layer)
{
mLayer = gameObject.layer;
UICamera uic = UICamera.FindCameraForLayer(mLayer);
mCam = (uic != null) ? uic.cachedCamera : NGUITools.FindCameraForLayer(mLayer);
SetChildLayer(cachedTransform, mLayer);
for (int i = 0, imax = drawCalls.size; i < imax; ++i)
{
mDrawCalls.buffer[i].gameObject.layer = mLayer;
}
}
UpdateWidgets();
// If the depth has changed, we need to re-sort the widgets
if (mDepthChanged)
{
mDepthChanged = false;
mWidgets.Sort(UIWidget.CompareFunc);
}
// Fill the draw calls for all of the changed materials
for (int i = 0, imax = mChanged.size; i < imax; ++i)
{
Fill(mChanged.buffer[i]);
}
// Update the clipping rects
UpdateDrawcalls();
mChanged.Clear();
mRebuildAll = false;
#if UNITY_EDITOR
mScreenSize = new Vector2(Screen.width, Screen.height);
UIRoot root = NGUITools.FindInParents <UIRoot>(gameObject);
if (root != null)
{
mScreenSize *= root.GetPixelSizeAdjustment(Screen.height);
}
#endif
}
/// <summary>
/// Make the following widget be managed by the panel.
/// </summary>
public void AddWidget (UIWidget w)
{
w.UpdateGeometry(Time.frameCount);
mUpdateScroll = true;
if (widgets.size == 0)
{
widgets.Add(w);
}
else if (mSortWidgets)
{
widgets.Add(w);
SortWidgets();
}
else if (UIWidget.PanelCompareFunc(w, widgets[0]) == -1)
{
widgets.Insert(0, w);
}
else
{
for (int i = widgets.size; i > 0; )
{
if (UIWidget.PanelCompareFunc(w, widgets[--i]) == -1) continue;
widgets.Insert(i+1, w);
break;
}
}
FindDrawCall(w);
}
