protected void Execute(UIEventData eventData)
{
try
{
var position = m_Position[this];
var size = m_Size[this];
var offsetMin = m_OffsetMin[this];
var offsetMax = m_OffsetMax[this];
var anchorMin = m_AnchorMin[this];
var anchorMax = m_AnchorMax[this];
var parentRect = eventData.Rect;
Vector2 min = new Vector2();
Vector2 max = new Vector2();
min.x = parentRect.x + position.x + anchorMin.x * parentRect.width + offsetMin.x;
min.y = parentRect.y + position.y + anchorMin.y * parentRect.height + offsetMin.y;
max.x = parentRect.x + position.x + size.x + parentRect.width * anchorMax.x - offsetMax.x;
max.y = parentRect.y + position.y + size.y + parentRect.height * anchorMax.y - offsetMax.y;
Execute(eventData, new Rect(min.x, min.y, max.x - min.x, max.y - min.y));
}
finally
{
if (eventData.WaitHandle != null)
{
eventData.WaitHandle.MarkDone();
}
}
}
/*-------------------------------------------------
* Event Handlers
* --------------------------------------------------*/
public void OnUpdateTerraResultsUI(UIEventData uiEventData)
{
this.UpdateTerraResultsUI(
uiEventData.terraCountMap,
uiEventData.postTerraformTerraCountMap
);
}
/*-------------------------------------------------
* Event Handlers
* --------------------------------------------------*/
public void OnSetAuraInfoTeamName(UIEventData uiEventData)
{
if (uiEventData.team.teamType == this.auraInfoUI.GetTeamType())
{
this.SetAuraInfoTeamName(uiEventData.team.teamName);
}
}
/// <summary>
/// Execute a UI event.
/// Events can be of multiple types <see cref="UIEventType"/>.
/// Some events are ran on a different thread.
/// </summary>
/// <param name="eventData"></param>
/// <param name="rect"></param>
protected virtual void Execute(UIEventData eventData, Rect rect)
{
eventData.Rect = new Rect(rect.position, rect.size);
try
{
GetSlotValues(m_Event, m_ValuesTmp);
if (eventData.WaitHandle != null)
{
foreach (var action in m_ValuesTmp)
{
eventData.WaitHandle.AddWait();
ThreadPool.QueueUserWorkItem(c => action.Invoke((UIEventData)c), eventData);
}
}
else
{
foreach (var action in m_ValuesTmp)
{
action.Invoke(eventData);
}
}
}
finally
{
m_ValuesTmp.Clear();
}
}
private void RaiseShowCharacterUIEvent(Character character)
{
UIEventData uiEventData = new UIEventData();
uiEventData.character = character;
this.showCharacterUI.Raise(uiEventData);
}
private void RaiseShowTerraUIEvent(Terra terra)
{
UIEventData uiEventData = new UIEventData();
uiEventData.terra = terra;
this.showTerraUI.Raise(uiEventData);
}
/*-------------------------------------------------
* Event Handlers
* --------------------------------------------------*/
public void OnUpdateAuraResultsUI(UIEventData uiEventData)
{
this.UpdateAuraResultsUI(
uiEventData.teamAuraScoreMap,
uiEventData.auraCountMap,
uiEventData.postTerraformAuraCountMap
);
}
private void RaiseSetAuraInfoTeamNameUIEvent(Team team)
{
UIEventData uiEventData = new UIEventData();
uiEventData.team = team;
this.setAuraInfoTeamName.Raise(uiEventData);
}
private void RaiseUpdateTerraUIEvent(Terra terra)
{
UIEventData uiEventData = new UIEventData();
uiEventData.terra = terra;
this.updateTerraUI.Raise(uiEventData);
}
/*-------------------------------------------------
* Event Triggers
* --------------------------------------------------*/
private void RaiseUpdateTerraResultsUI(Dictionary <string, int> terraCountMap, Dictionary <string, int> postTerraformTerraCountMap)
{
UIEventData uiEventData = new UIEventData();
uiEventData.terraCountMap = terraCountMap;
uiEventData.postTerraformTerraCountMap = postTerraformTerraCountMap;
this.updateTerraResults.Raise(uiEventData);
}
protected override void Execute(UIEventData eData, Rect rect)
{
if (eData.EventType == UIEventType.Layout)
{
var sprite = m_SpriteInput[this];
if (sprite != null)
{
m_SpriteData = new SpriteData()
{
padding = DataUtility.GetPadding(sprite),
rect = sprite.rect,
outerUv = DataUtility.GetOuterUV(sprite),
innerUv = DataUtility.GetInnerUV(sprite),
hasBorder = sprite.border.sqrMagnitude > 0,
border = sprite.border,
packed = sprite.packed,
wrapMode = sprite.texture.wrapMode,
hasSprite = true
}
}
;
else
{
m_SpriteData = new SpriteData()
{
rect = new Rect(0, 0, 100, 100)
}
};
}
else if (eData.EventType == UIEventType.PreRepaint)
{
var fillAmount = Mathf.Clamp01(m_FillAmount[this]);
var color = m_Color[this];
var pivot = m_Pivot[this];
lock (m_VertexHelper)
{
GenerateFilledSprite(m_VertexHelper, m_SpriteData, rect, pivot, color, fillAmount);
}
}
else if (eData.EventType == UIEventType.Repaint)
{
var sprite = m_SpriteInput[this];
var matrix = m_Matrix[this];
var mat = m_Material[this];
m_VertexHelper.FillMesh(m_Mesh);
m_VertexHelper.Clear();
m_PropertyBlock.Clear();
if (sprite != null)
{
m_PropertyBlock.SetTexture(m_MainTexProp, sprite.texture);
}
eData.RenderBuffer.Render(m_Mesh, matrix * Matrix4x4.Translate(new Vector3(0, 0, m_ZOffset[this])), mat, m_PropertyBlock);
}
base.Execute(eData, rect);
}
private void RaiseUpdateAuraResultsUI(Dictionary <string, int> teamAuraScoreMap, Dictionary <Tile, Dictionary <string, int> > auraCountMap, Dictionary <Tile, Dictionary <string, int> > postTerraformAuraCountMap)
{
UIEventData uIEventData = new UIEventData();
uIEventData.teamAuraScoreMap = teamAuraScoreMap;
uIEventData.auraCountMap = auraCountMap;
uIEventData.postTerraformAuraCountMap = postTerraformAuraCountMap;
this.updateAuraResults.Raise(uIEventData);
}
protected override void Execute(UIEventData eData, Rect rect)
{
if (eData.EventType == UIEventType.Layout)
{
var sprite = m_SpriteInput[this];
if (sprite != null)
{
m_SpriteData = new SpriteData()
{
rect = sprite.rect,
outerUv = DataUtility.GetOuterUV(sprite),
innerUv = DataUtility.GetInnerUV(sprite),
hasBorder = sprite.border.sqrMagnitude > 0,
border = sprite.border,
packed = sprite.packed,
wrapMode = sprite.texture.wrapMode,
hasSprite = true
}
}
;
else
{
m_SpriteData = new SpriteData()
{
rect = new Rect(0, 0, 100, 100)
}
};
}
else if (eData.EventType == UIEventType.PreRepaint)
{
var color = m_Color[this];
var vertexHelper = eData.MeshRepository.GetVertexHelper(guid);
GenerateTiledSprite(vertexHelper, m_SpriteData, rect, color);
}
else if (eData.EventType == UIEventType.Repaint)
{
var sprite = m_SpriteInput[this];
var matrix = m_Matrix[this];
var mat = m_Material[this];
var vertexHelper = eData.MeshRepository.GetVertexHelper(guid);
var mesh = eData.MeshRepository.GetMesh(guid);
MaterialPropertyBlock propertyBlock = null;
vertexHelper.FillMesh(mesh);
if (sprite != null)
{
propertyBlock = eData.MeshRepository.GetPropertyBLock(guid);
propertyBlock.SetTexture(m_MainTexProp, sprite.texture);
}
eData.RenderBuffer.Render(mesh, matrix * Matrix4x4.Translate(new Vector3(0, 0, m_ZOffset[this])), mat, propertyBlock);
}
base.Execute(eData, rect);
}
/*-------------------------------------------------
* Helpers
* --------------------------------------------------*/
private void UpdateTerraform(UIEventData uiEventData)
{
this.RaiseUpdateTerraResultsUI(
uiEventData.terraCountMap,
uiEventData.postTerraformTerraCountMap
);
this.RaiseUpdateAuraResultsUI(
uiEventData.teamAuraScoreMap,
uiEventData.auraCountMap,
uiEventData.postTerraformAuraCountMap
);
}
private void RaiseShowTerraformUI(List <Tile> terraformingTiles, Dictionary <string, int> terraCountMap)
{
UIEventData uiEventData = new UIEventData();
uiEventData.terraCountMap = terraCountMap;
uiEventData.postTerraformTerraCountMap = this.map.GetPostTerraformTerraCountMap(terraformingTiles, terraCountMap);
uiEventData.auraCountMap = this.map.GetCurrentAuraCountMap(terraformingTiles);
uiEventData.postTerraformAuraCountMap = this.map.GetPostTerraformAuraCountMap(terraformingTiles);
uiEventData.teamAuraScoreMap = this.map.GetMapTeamView().GetTeamScoreMap();
this.showTerraformUI.Raise(uiEventData);
}
protected override void Execute(UIEventData eData, Rect rect)
{
if (eData.EventType == UIEventType.Layout)
{
var sprite = m_SpriteInput[this];
if (sprite != null)
{
m_SpriteData = new SpriteData()
{
padding = DataUtility.GetPadding(sprite),
outerUv = DataUtility.GetOuterUV(sprite),
innerUv = DataUtility.GetInnerUV(sprite),
border = sprite.border,
hasSprite = true
}
}
;
else
{
m_SpriteData = new SpriteData();
}
}
else if (eData.EventType == UIEventType.PreRepaint)
{
var color = m_Color[this];
var pivot = m_Pivot[this];
var vertexHelper = eData.MeshRepository.GetVertexHelper(guid);
var localRect = new Rect(-pivot.x * rect.width, -pivot.y * rect.height, rect.width, rect.height);
GenerateSlicedSprite(vertexHelper, m_SpriteData, localRect, color);
}
else if (eData.EventType == UIEventType.Repaint)
{
var sprite = m_SpriteInput[this];
var matrix = m_Matrix[this];
var mat = m_Material[this];
var pivot = m_Pivot[this];
var vertexHelper = eData.MeshRepository.GetVertexHelper(guid);
var mesh = eData.MeshRepository.GetMesh(guid);
MaterialPropertyBlock propertyBlock = null;
vertexHelper.FillMesh(mesh);
if (sprite != null)
{
propertyBlock = eData.MeshRepository.GetPropertyBLock(guid);
propertyBlock.SetTexture(m_MainTexProp, sprite.texture);
}
eData.RenderBuffer.Render(mesh, Matrix4x4.Translate(new Vector3(rect.x + pivot.x * rect.width, rect.y + pivot.y * rect.height, m_ZOffset[this])) * matrix, mat, propertyBlock);
}
base.Execute(eData, rect);
}
protected override void Execute(UIEventData eData, Rect rect)
{
if (eData.EventType == UIEventType.Layout)
{
var sprite = m_SpriteInput[this];
if (sprite != null)
{
m_SpriteData = new SpriteData()
{
padding = DataUtility.GetPadding(sprite),
rect = sprite.rect,
outerUv = DataUtility.GetOuterUV(sprite)
}
}
;
else
{
m_SpriteData = new SpriteData()
{
rect = new Rect(0, 0, 100, 100),
outerUv = new Vector4(0, 0, 1, 1)
}
};
}
else if (eData.EventType == UIEventType.PreRepaint)
{
var color = m_Color[this];
var pivot = m_Pivot[this];
lock (m_VertexHelper)
{
GenerateSimpleSprite(m_VertexHelper, m_SpriteData, rect, pivot, color);
}
}
else if (eData.EventType == UIEventType.Repaint)
{
var sprite = m_SpriteInput[this];
var matrix = m_Matrix[this];
var mat = m_Material[this];
m_VertexHelper.FillMesh(m_Mesh);
m_VertexHelper.Clear();
m_PropertyBlock.Clear();
if (sprite != null)
{
m_PropertyBlock.SetTexture(m_MainTexProp, sprite.texture);
}
eData.RenderBuffer.Render(m_Mesh, matrix * Matrix4x4.Translate(new Vector3(0, 0, m_ZOffset[this])), mat, m_PropertyBlock);
}
base.Execute(eData, rect);
}
protected override void Execute(UIEventData eventData, Rect rect)
{
if (eventData.EventType == UIEventType.Layout)
{
var font = m_Font[this];
if (font != null)
{
m_FontData = new FontData()
{
hasFont = true,
dynamic = font.dynamic,
size = font.fontSize,
material = font.material
}
}
;
else
{
m_FontData = new FontData();
}
var text = m_Text[this];
var fontSize = m_FontSize[this];
var pivot = m_Pivot[this];
float pixelPerUnit = GetPixelsPerUnit(m_FontData, fontSize);
m_TextGenerator.Populate(text, GetSettings(font, fontSize, m_Color[this], rect, pivot, pixelPerUnit));
m_TextVerts = m_TextGenerator.verts;
}
else if (eventData.EventType == UIEventType.PreRepaint)
{
var fontSize = m_FontSize[this];
float pixelPerUnit = GetPixelsPerUnit(m_FontData, fontSize);
lock (m_VertexHelper)
{
RebuildMesh(m_VertexHelper, pixelPerUnit);
}
}
else if (eventData.EventType == UIEventType.Repaint)
{
var matrix = m_Matrix[this];
var mat = m_Material[this];
m_VertexHelper.FillMesh(m_Mesh);
m_VertexHelper.Clear();
eventData.RenderBuffer.Render(m_Mesh, matrix * Matrix4x4.Translate(rect.position), mat ?? m_FontData.material, m_PropertyBlock);
}
base.Execute(eventData, rect);
}
/*-------------------------------------------------
* Event Handlers
* --------------------------------------------------*/
public void OnUpdateTerra(UIEventData uiEventData)
{
UpdateTerra(uiEventData.terra);
}
private void RaiseHideDangerZoneUIEvent()
{
UIEventData uiEventData = new UIEventData();
this.hideDangerZone.Raise(uiEventData);
}
private void RaiseShowArrangeTilesUIEvent()
{
UIEventData uiEventData = new UIEventData();
this.showArrangeTiles.Raise(uiEventData);
}
private void RaiseHideArrangeTilesUIEvent()
{
UIEventData uiEventData = new UIEventData();
this.hideArrangeTiles.Raise(uiEventData);
}
public void OnHideArrangeTiles(UIEventData uiEventData)
{
HideBattleArrangeTiles();
}
public void OnHideDangerZone(UIEventData uiEventData)
{
HideBattleDangerZone();
}
/*-------------------------------------------------
* Event Handlers
* --------------------------------------------------*/
public void OnShowDangerZone(UIEventData uiEventData)
{
ShowBattleDangerZone();
}
private void RaiseHideTerraUIEvent()
{
UIEventData uIEventData = new UIEventData();
this.hideTerraUI.Raise(uIEventData);
}
/*-------------------------------------------------
* Event Handlers
* --------------------------------------------------*/
public void OnUpdateTerraform(UIEventData uiEventData)
{
this.UpdateTerraform(uiEventData);
}
/*-------------------------------------------------
* Event Handlers
* --------------------------------------------------*/
public void OnUpdateCharacter(UIEventData uiEventData)
{
UpdateCharacter(uiEventData.character);
}
private void RaiseHideTerraformUI()
{
UIEventData uiEventData = new UIEventData();
this.hideTerraformUI.Raise(uiEventData);
}
public void OnShowArrangeTiles(UIEventData uiEventData)
{
ShowBattleArrangeTiles();
}
