public void Replace(Material replacementMaterial)
{
if (renderer && material)
{
renderer.SetMaterial(replacementMaterial, 0);
}
}
protected override void UpdateMaterial()
{
base.UpdateMaterial();
if (shouldEmojilize)
{
if (IsActive())
{
CreateEmojiCanvasRenderer();
emojiCanvasRenderer.materialCount = 1;
if (config.material != null)
{
emojiCanvasRenderer.SetMaterial(GetModifiedEmojiMaterial(config.material), 0);
}
else
{
emojiCanvasRenderer.SetMaterial(materialForRendering, 0);
}
emojiCanvasRenderer.SetTexture(config.texture);
}
}
else
{
if (emojiCanvasRenderer != null)
{
emojiCanvasRenderer.Clear();
}
}
}
void Start()
{
viewMesh = new Mesh();
viewMesh.name = "view Mesh";
//viewMeshFilter.mesh = viewMesh;
canvas.Clear();
canvas.SetMesh(viewMesh);
canvas.SetMaterial(material, 0);
}
/// <summary>
/// Waits for the renderer to initialize.
/// </summary>
/// <returns></returns>
IEnumerator WaitForRenderer()
{
while (m_Renderer.materialCount < 1)
{
yield return(null);
}
m_Renderer.SetMaterial(newMaterial, 0);
initialized = true;
yield break;
}
/// <summary>
///
/// </summary>
protected override void UpdateMaterial()
{
//Debug.Log("*** STO-UI - UpdateMaterial() *** FRAME (" + Time.frameCount + ")");
//if (!this.IsActive())
// return;
if (m_canvasRenderer == null)
{
m_canvasRenderer = this.canvasRenderer;
}
m_canvasRenderer.materialCount = 1;
m_canvasRenderer.SetMaterial(materialForRendering, 0);
m_canvasRenderer.SetTexture(mainTexture);
#if UNITY_EDITOR
if (m_sharedMaterial != null && gameObject.name != "TMP SubMeshUI [" + m_sharedMaterial.name + "]")
{
gameObject.name = "TMP SubMeshUI [" + m_sharedMaterial.name + "]";
}
#endif
}
public void Start()
{
_collider = GetComponent <BoxCollider2D>();
_canvasRenderer = GetComponent <CanvasRenderer>();
_canvasRenderer.SetMaterial(Material, Texture2D.whiteTexture);
_collider.size = new Vector2(Width * 64, Height * 64);
}
private void UpdateStatsVisual()
{
Mesh mesh = new Mesh();
Vector3[] vertices = new Vector3[6];
Vector2[] uv = new Vector2[6];
int[] triangles = new int[3 * 5];
float angleIncrement = 360f / 5;
float radarChartSize = 99f;
Vector3 attackVertex = Quaternion.Euler(0, 0, -angleIncrement * 0) * Vector3.up * radarChartSize * stats.GetStatAmountNormalized(Stats.Type.Attack);
int attackVertexIndex = 1;
Vector3 defenceVertex = Quaternion.Euler(0, 0, -angleIncrement * 1) * Vector3.up * radarChartSize * stats.GetStatAmountNormalized(Stats.Type.Defence);
int defenceVertexIndex = 2;
Vector3 speedVertex = Quaternion.Euler(0, 0, -angleIncrement * 2) * Vector3.up * radarChartSize * stats.GetStatAmountNormalized(Stats.Type.Speed);
int speedVertexIndex = 3;
Vector3 manaVertex = Quaternion.Euler(0, 0, -angleIncrement * 3) * Vector3.up * radarChartSize * stats.GetStatAmountNormalized(Stats.Type.Mana);
int manaVertexIndex = 4;
Vector3 healthVertex = Quaternion.Euler(0, 0, -angleIncrement * 4) * Vector3.up * radarChartSize * stats.GetStatAmountNormalized(Stats.Type.Health);
int healthVertexIndex = 5;
vertices[0] = Vector3.zero;
vertices[attackVertexIndex] = attackVertex;
vertices[defenceVertexIndex] = defenceVertex;
vertices[speedVertexIndex] = speedVertex;
vertices[manaVertexIndex] = manaVertex;
vertices[healthVertexIndex] = healthVertex;
triangles[0] = 0;
triangles[1] = attackVertexIndex;
triangles[2] = defenceVertexIndex;
triangles[3] = 0;
triangles[4] = defenceVertexIndex;
triangles[5] = speedVertexIndex;
triangles[6] = 0;
triangles[7] = speedVertexIndex;
triangles[8] = manaVertexIndex;
triangles[9] = 0;
triangles[10] = manaVertexIndex;
triangles[11] = healthVertexIndex;
triangles[12] = 0;
triangles[13] = healthVertexIndex;
triangles[14] = attackVertexIndex;
mesh.vertices = vertices;
mesh.uv = uv;
mesh.triangles = triangles;
raderMeshCanvasRenderer.SetMesh(mesh);
raderMeshCanvasRenderer.SetMaterial(radarMaterial, null);
//transform.Find("attackBar").localScale = new Vector3(1, stats.GetStatAmountNormalized(Stats.Type.Attack));
//transform.Find("defenceBar").localScale = new Vector3(1, stats.GetStatAmountNormalized(Stats.Type.Defence));
}
/*
* Add/remove componenets depending on parent
*/
void TakeCareOfComponenets()
{
if (isCanvas)
{
DestroyImmediate(GetComponent <MeshFilter>());
DestroyImmediate(GetComponent <MeshRenderer>());
if (GetComponent <CanvasRenderer>() == null)
{
gameObject.AddComponent <CanvasRenderer>();
}
cr = GetComponent <CanvasRenderer>();
cr.SetMaterial(useMaterial, null);
}
else
{
DestroyImmediate(GetComponent <CanvasRenderer>());
if (GetComponent <MeshFilter>() == null)
{
gameObject.AddComponent <MeshFilter>();
}
if (GetComponent <MeshRenderer>() == null)
{
gameObject.AddComponent <MeshRenderer>();
}
mf = GetComponent <MeshFilter>();
mr = GetComponent <MeshRenderer>();
mr.sharedMaterial = useMaterial;
sortingLayer = mr.sortingLayerID;
orderInLayer = mr.sortingOrder;
}
}
void Start()
{
if (m_Initialized)
{
return;
}
pCanvasRenderer = gameObject.GetComponent <CanvasRenderer>();
pCanvasRenderer.SetMaterial(m_Mat, null);
pRectTransform = gameObject.GetComponent <RectTransform>();
//m_MeshFilter = gameObject.AddComponent< MeshFilter >();
//gameObject.AddComponent< MeshRenderer >();
m_NormalizedGraphValues = new float[m_Resolution];
for (int i = 0; i < m_NormalizedGraphValues.Length; i++)
{
m_NormalizedGraphValues[i] = 1;
}
//if( m_Mat != null ) renderer.material = m_Mat;
m_Mesh = new Mesh();
CreateMesh();
m_Initialized = true;
}
public void UpdateStatusMesh(float[] normalizedValues)
{
if (chartMesh)
{
Destroy(chartMesh);
}
chartMesh = new Mesh();
Vector3[] vertices = new Vector3[normalizedValues.Length + 1];
int[] triangles = new int[3 * normalizedValues.Length];
float deltaAngle = 360f / normalizedValues.Length;
vertices[0] = Vector3.zero;
for (int i = 0; i < normalizedValues.Length; i++)
{
vertices[i + 1] = GetVerticesPos(normalizedValues[i], deltaAngle * i);
triangles[i * 3] = 0;
triangles[i * 3 + 1] = i + 1;
triangles[i * 3 + 2] = i + 2 >= normalizedValues.Length + 1 ? 1 : i + 2;
}
chartMesh.vertices = vertices;
chartMesh.triangles = triangles;
canvasRenderer.SetMesh(chartMesh);
canvasRenderer.SetMaterial(chartMaterial, null);
}
void Awake()
{
canvasRenderer = gameObject.AddComponent <CanvasRenderer>();
canvasRenderer.SetMaterial(material, null);
mesh = new Mesh();
datas = new Linedata();
}
// Use this for initialization
void Start()
{
Color32 color = new Color32(255, 0, 0, 255);
//color = new Color32();
UIVertex[] data = new UIVertex[] {
new UIVertex()
{
position = new Vector3(0f, 0f, 0f), color = color
},
new UIVertex()
{
position = new Vector3(0f, 50f, 0f), color = color
},
new UIVertex()
{
position = new Vector3(50f, 50f, 50f), color = color
},
new UIVertex()
{
position = new Vector3(50f, 0f, 50f), color = color
}
};
CanvasRenderer canvasRender = GetComponent <CanvasRenderer>();
canvasRender.Clear();
Material defaultMaterial = new Material(Shader.Find("UI/Default"));
canvasRender.SetMaterial(defaultMaterial, null);
canvasRender.SetVertices(data, data.Length);
Debug.Log("start");
}
public void Draw()
{
canvasRender.Clear();
canvasRender.SetMaterial(wallMaterial, null);
canvasRender.GetMaterial().color = Color.white;
canvasRender.SetVertices(vertlist);
//Debug.Log("cout: " + list.Count);
}
protected override void UpdateMaterial()
{
if (m_canvasRenderer == null)
{
m_canvasRenderer = canvasRenderer;
}
m_canvasRenderer.materialCount = 1;
m_canvasRenderer.SetMaterial(materialForRendering, 0);
m_canvasRenderer.SetTexture(mainTexture);
}
private void DrawBarChart()
{
if (controller.SeriesCount < 1)
{
return;
}
float mBarHeight = chartHolder.rect.height;
float mBarSector = chartHolder.rect.width / controller.SeriesCount;
float mBarWidth = mBarSector * 0.67f;
for (int idx = 0; idx < controller.SeriesCount; idx++)
{
float x = (idx + 0.5f) * mBarSector;
float y = controller.values[idx] / controller.GetTotalMaxValue() * mBarHeight;
Vector3[] lines = new Vector3[] { new Vector3(x, 0), new Vector3(x, y) };
Mesh lineMesh = ChartUtils.GenerateLineMesh(lines, mBarWidth);
string name = ChartUtils.NameGenerator(chartChildString, idx);
GameObject obj = chartHolder.Find(name).gameObject;
CanvasRenderer renderer = obj.GetComponent <CanvasRenderer>();
renderer.Clear();
renderer.SetMaterial(controller.materials[idx], null);
renderer.SetMesh(lineMesh);
RectTransform rt;
if (obj.transform.childCount > 0)
{
rt = obj.transform.GetChild(0) as RectTransform;
}
else
{
var go = new GameObject();
go.transform.SetParent(obj.transform);
var t = go.AddComponent <Text>();
t.alignment = TextAnchor.MiddleCenter;
t.color = Color.black;
t.font = font;
rt = go.transform as RectTransform;
}
rt.localPosition = new Vector3(x, -7);
var text = obj.GetComponentInChildren <Text>();
if (text != null)
{
text.text = controller.values[idx].ToString();
}
}
}
private void UpdateMat()
{
Debug.Log("Updated material val");
CanvasRenderer image = GetComponent <CanvasRenderer>();
Material existingGlobalMat = image.GetMaterial();
Material updatedMaterial = new Material(existingGlobalMat);
updatedMaterial.SetInt("unity_GUIZTestMode", (int)comparison);
image.SetMaterial(updatedMaterial, 0);
apply = false;
}
/// <summary>
/// Method to draw / display the 2D Radar Chart within the UI.
/// </summary>
/// <param name="mesh">Mesh of the 2D Radar Chart representing the selected Time Slice in the 3D Radar Chart.</param>
private void setRadarChart2DMesh(Mesh mesh)
{
// set the mesh
timeSliceRadarUICanvasRenderer.SetMesh(mesh);
// set color
Material polygonMeshMat = new Material(Shader.Find("UI/Default"));
polygonMeshMat.color = tdrcInterface.cnfgTmSlcRdrUI_radarColor;
timeSliceRadarUICanvasRenderer.SetMaterial(polygonMeshMat, null);
}
private void SetZTestMode(CanvasRenderer r)
{
if (r.materialCount == 0)
{
return;
}
Material mat = new Material(r.GetMaterial(0));
mat.SetInt("unity_GUIZTestMode", (int)(enabled ? CompareFunction.Always : CompareFunction.LessEqual));
r.SetMaterial(mat, 0);
}
private void Init()
{
if (_canvasRenderer != null)
{
return;
}
_canvasRenderer = GetComponent <CanvasRenderer>();
_canvasRenderer.SetMaterial(_material, null);
}
protected override void _drawAxisBackground(List <UIVertex> pVertexList)
{
Material pMat = new Material(AxisMaterial);
pMat.SetColor("_TintColor", MarginBackgroundColor);
CanvasRenderer pCanvasRenderer = NGraphUtils.AddCanvasRenderer(mAxesBackgroundGo);
pCanvasRenderer.Clear();
pCanvasRenderer.SetMaterial(pMat, null);
pCanvasRenderer.SetVertices(pVertexList);
}
/// <summary>
/// Redraw the axis based on the lenght and height of the chart area.
/// </summary>
private void UpdateAxis()
{
lines = new Vector3[4];
lines[0] = Vector3.zero;
lines[1] = new Vector3(0, axisHolder.rect.height);
lines[2] = lines[0];
lines[3] = new Vector3(axisHolder.rect.width, 0);
axisMesh = ChartUtils.GenerateLineMesh(lines, 2f);
//canvasRenderer.Clear();
canvasRenderer.SetMaterial(ChartUtils.BlackMaterial, null);
canvasRenderer.SetMesh(axisMesh);
}
IEnumerator LoadImage()
{
WWW www = new WWW(url2);
yield return(www);
//renderer.material.mainTexture = www.texture;
//image script material = sprite- default material
renderer = GetComponent <Renderer>();
canvRenderer = GetComponent <CanvasRenderer>();
canvRenderer.SetMaterial(canvRenderer.GetMaterial(), www.texture);
//renderer.material.mainTexture = www.texture;
}
// Use this for initialization
void Start()
{
renderer = GetComponent <CanvasRenderer>();
mesh = new Mesh();
mesh.SetVertices(new List <Vector3>(points));
mesh.SetTriangles(new int[] { 0, 1, 2 }, 0);
renderer.Clear();
renderer.SetMaterial(material, null);
renderer.SetMesh(mesh);
player = FindObjectOfType <PlayerController>();
}
protected override void UpdateMaterial()
{
if (m_canvasRenderer == null)
{
m_canvasRenderer = canvasRenderer;
}
m_canvasRenderer.materialCount = 1;
m_canvasRenderer.SetMaterial(((Graphic)this).materialForRendering, 0);
m_canvasRenderer.SetTexture(((Graphic)this).mainTexture);
if (m_sharedMaterial != null && base.gameObject.name != "TMP SubMeshUI [" + m_sharedMaterial.name + "]")
{
base.gameObject.name = "TMP SubMeshUI [" + m_sharedMaterial.name + "]";
}
}
public override void setupGraphHierarchy()
{
base.setupGraphHierarchy();
CanvasRenderer pCanvasRenderer = NGraphUtils.AddCanvasRenderer(mMeshesContainer);
Material pMat = new Material(AxisMaterial);
pMat.SetColor("_TintColor", GridLinesColorMajor);
pCanvasRenderer.Clear();
pCanvasRenderer.SetMaterial(pMat, null);
NGraphUtils.DrawRect(new Rect(adjustPointX(-5) - (GridLinesThicknesMajor / 2f), adjustPointY(YRange.y), GridLinesThicknesMajor, adjustPointY(YRange.x) * 2), pCanvasRenderer);
}
void ShowProgressionCircle()
{
_mesh = new Mesh();
_vertices = new Vector3[_levelCount * 3];
_vertices[0] = new Vector3(0f, 0f, 0f) * 10f;
_vertices[1] = new Vector3(0f, 1f, 0f) * 10f;
_vertices[2] = new Vector3(-1f, 1f, 0f) * 10f;
// _vertices[3] = new Vector3(-1f,0f,0f) * 10f;
_mesh.vertices = _vertices;
_mesh.uv = new Vector2[] { new Vector2(1 - 1f / _resolution, 1), new Vector2(1, 1), new Vector2(1, 1) };
_mesh.triangles = new int[] { 0, 1, 2 };
_renderer.SetMaterial(_material, _texture);
_renderer.SetMesh(_mesh);
}
void MeshRenderTest()
{
CanvasRenderer cr = meshTest.AddComponent <CanvasRenderer>();
Mesh mesh = new Mesh();
mesh.vertices = new Vector3[] {
new Vector3(0, 0, 0),
new Vector3(0, 100, 0),
new Vector3(100, 100, 0),
new Vector3(100, 0, 0)
};
mesh.triangles = new int[] { 0, 1, 2, 2, 3, 0 };
// mesh.colors = new Color[]{
// Color.black,
// Color.blue,
// Color.cyan,
// Color.gray
// };
cr.Clear();
cr.SetMaterial(material, null);
// cr.SetMesh (mesh);
Vector3[] vertices = mesh.vertices;
int[] triangles = mesh.triangles;
Vector3[] normals = mesh.normals;
Vector2[] uv = mesh.uv;
UIVertex vertex;
// Debug.Log (uv.Length);
List <UIVertex> vertexList = new List <UIVertex> ();
for (int i = 0; i < triangles.Length; i++)
{
vertex = new UIVertex();
int triangle = triangles[i];
vertex.position = ((vertices[triangle] - mesh.bounds.center) * 1);
vertex.uv0 = Vector2.one;
vertex.normal = Vector3.forward;
vertexList.Add(vertex);
if (i % 3 == 0)
{
vertexList.Add(vertex);
}
}
cr.SetVertices(vertexList);
}
void Start()
{
arrowHead.sizeDelta = new Vector2(arrowHead.rect.width * ARROW_HEAD_SCALE_COEFFICIENT, arrowHead.rect.height * ARROW_HEAD_SCALE_COEFFICIENT);
arrowTail.sizeDelta = new Vector2(arrowTail.rect.width, arrowTail.rect.height * ARROW_TAIL_SCALE_COEFFICIENT);
scoreKeepingScript = GameObject.Find("World").GetComponent <ScoreKeeping> ();
ballManagerScript = GetComponent <BallManager> ();
cameraFollowScript = camera3D.GetComponent <CameraFollow> ();
levelManage = GameObject.Find("LevelManager");
levelManagerScript = levelManage == null ? null : levelManage.GetComponent <LevelManager> ();
arrowTailRenderer = arrowTail.GetComponent <CanvasRenderer> ();
arrowTailRenderer.SetMaterial(arrowTailShader, null);
distance = 0;
arrowScalePercent = 0;
overUI = false;
}
void Start()
{
if (m_ActorNode == null)
{
return;
}
m_Renderer = GetComponent <CanvasRenderer>();
m_Renderer.Clear();
m_Renderer.SetAlpha(1.0f);
m_Renderer.SetColor(Color.white);
m_Renderer.SetMesh(m_Mesh);
m_Renderer.materialCount = 1;
m_Renderer.SetMaterial(m_Material, 0);
m_VertexPositionBuffer = m_ActorNode.MakeVertexPositionBuffer();
}
private void GenerateMesh()
{
int count = values.Count;
if (count > 0)
{
_mesh = new Mesh();
_vertices = new Vector3[count + 1];
_uv = new Vector2[count + 1];
_triangles = new int[3 * count];
float angleIncrement = 360f / count;
float radarChartSize = 145f;
// uv
_uv[0] = Vector2.zero;
for (int i = 0; i < count; i++)
{
_uv[i + 1] = Vector2.one;
}
// vertices and tris
_vertices[0] = Vector3.zero;
for (int i = 0; i < count; i++)
{
_vertices[i + 1] = Quaternion.Euler(0, 0, -angleIncrement * i) * Vector3.up * radarChartSize * values[i].GetFraction;
// Tris
_triangles[i * 3] = 0;
for (int j = 0; j < 2; j++)
{
_triangles[i * 3 + j + 1] = i + j + 1;
}
}
_triangles[3 * count - 1] = 1;
_fullVertices = new Vector3[count + 1];
Array.Copy(_vertices, _fullVertices, _vertices.Length);
_mesh.vertices = _vertices;
_mesh.uv = _uv;
_mesh.triangles = _triangles;
canvasRenderer.SetMesh(_mesh);
canvasRenderer.SetMaterial(chartMaterial, null);
}
}
