private static IRenderer CreateRenderer(RendererData renderer, ContentChest contentChest)
{
if (renderer == null)
{
return(null);
}
switch (renderer.Name)
{
case "StaticRenderer":
return(new StaticRenderer()
{
ContentChest = contentChest
});
case "TransitionRenderer":
return(new TransitionRenderer
{
ContentChest = contentChest,
TransitionTextures = renderer.Textures,
MaxTransition = renderer.Textures.Length - 1,
TransitionTime = float.Parse(renderer.GetParameter("TransitionTime"))
});
default: return(null);
}
}
protected JobHandle Render(JobHandle inputDeps)
{
if (injectRendererDatas.Length != rendererData.Length)
{
DestroyRendererArrays();
CreateRendererArrays(injectRendererDatas.Length);
rendererData = new RendererData(injectRendererDatas.Length);
}
var handle = new UpdateDataJob {
matrices = matrices, yPositions = yPositions, units = injectRendererDatas.stateDatas
}.Schedule(injectRendererDatas.Length, 64, inputDeps);
handle.Complete();
matrices.CopyTo(rendererData.matrices);
yPositions.CopyTo(rendererData.yPositions);
for (int i = 0; i < injectRendererDatas.Length; i += 1023)
{
var len = Mathf.Min(injectRendererDatas.Length - i, 1023);
Array.Copy(rendererData.matrices, i, tempMatrices, 0, len);
Array.Copy(rendererData.yPositions, i, tempYPositions, 0, len);
materialPropertyBlock.SetFloatArray("_YPos", tempYPositions);
for (int j = 0; j < StateGraph.rendererData.SubMeshCount; j++)
{
Graphics.DrawMeshInstanced(StateGraph.rendererData.Mesh, j, StateGraph.rendererData.Materials[j], tempMatrices, len, materialPropertyBlock, StateGraph.rendererData.ShadowCastingMode, StateGraph.rendererData.ReceivesShadows);
}
}
return(handle);
}
//
static private void ExpandRendererDataPool(int count)
{
for (int i = 0; i < count; i++)
{
RendererData instance = new RendererData();
sRendererDataPool.Push(instance);
}
}
public RendererData GetBitModifierRendererData()
{
RendererData data = new RendererData();
data.color = Color.White;
data.layer = GameSettings.bitModifierLayer;
data.rect = new Rectangle(0, 0, GameSettings.bitSize, GameSettings.bitSize);
return(data);
}
public RendererData GetDestroyerRendererData()
{
RendererData data = new RendererData();
data.color = Color.White;
data.layer = GameSettings.destroyerLayer;
data.rect = new Rectangle(0, 0, GameSettings.destroyerSize, GameSettings.destroyerSize);
data.texture = _resourceManager.GetCommonTexture(GameSettings.destroyerTextureName);
return(data);
}
public RendererData MaskRendererData()
{
RendererData data = new RendererData();
data.color = Color.White;
data.layer = GameSettings.maskLayer;
data.rect = new Rectangle(0, 0, GameSettings.maskWidth, GameSettings.MaskHeight);
data.texture = _resourceManager.GetCommonTexture(GameSettings.maskTextureName);
return(data);
}
public RendererData BackgroundRendererData()
{
RendererData data = new RendererData();
data.color = Color.White;
data.layer = GameSettings.backgroundLayer;
data.rect = new Rectangle(0, 0, GameSettings.backgroundWidth, GameSettings.backgroundHeight);
data.texture = _resourceManager.GetCommonTexture(GameSettings.gameTextureName);
return(data);
}
public RendererData GetBoardRendererData()
{
RendererData data = new RendererData();
data.color = Color.White;
data.layer = GameSettings.boardLayer;
Point pos = GameSettings.BoardCoord();
data.rect = new Rectangle(pos.X, pos.Y, GameSettings.BoardSize.X, GameSettings.BoardSize.Y);
data.texture = _resourceManager.GetCommonTexture(GameSettings.boardTextureName);
return(data);
}
//
static private void ReleaseRendererDataInstance(RendererData instance)
{
if (instance == null || sRendererDataPool.Contains(instance))
{
return;
}
instance.renderer = null;
instance.submeshIndices.Clear();
sRendererDataPool.Push(instance);
}
public ButtonData ButtonRendererData()
{
ButtonData data = new ButtonData();
RendererData rendererData = new RendererData();
rendererData.color = Color.White;
rendererData.layer = GameSettings.buttonLayer;
rendererData.rect = new Rectangle(0, 0, GameSettings.buttonWidth, GameSettings.buttonHeight);
rendererData.texture = _resourceManager.GetCommonTexture(GameSettings.defaultButtonTextureName);
rendererData.auxTexture = _resourceManager.GetCommonTexture(GameSettings.pressedButtonTextureName);
data.data = rendererData;
return(data);
}
void SetupRenderers()
{
using (var renderers = TempList <Renderer> .Get())
{
GetComponentsInChildren <Renderer>(
includeInactive: true,
result: renderers.buffer
);
this.renderers = renderers.buffer.ToArray();
if (rendererData.Length == 0)
{
return;
}
int dataIndex = 0;
for (int i = 0; i < renderers.Count; ++i)
{
Renderer rend = renderers[i];
if (!(rend is MeshRenderer) && !(rend is SkinnedMeshRenderer))
{
continue;
}
if (dataIndex >= rendererData.Length)
{
break;
}
RendererData data = rendererData[dataIndex++];
rend.shadowCastingMode = data.shadowCastingMode;
rend.receiveShadows = data.receiveShadows;
if (Application.isPlaying && data.overrideMaterials)
{
if (data.useSharedMaterial)
{
rend.sharedMaterials = data.materials;
}
else
{
rend.materials = data.materials;
}
}
}
}
}
// Recursively follows hierarchy of objects from t, searches for Renderers and adds them to the list.
// Breaks if another Highlighter component found
private void GrabRenderers(Transform t)
{
GameObject g = t.gameObject;
// Find all Renderers on the current GameObject g, filter them and add to the sRendererData list
g.GetComponents <Renderer>(sRenderers);
for (int i = 0, imax = sRenderers.Count; i < imax; i++)
{
Renderer renderer = sRenderers[i];
if (rendererFilterToUse(renderer, sSubmeshIndices))
{
RendererData rendererData = GetRendererDataInstance();
rendererData.renderer = renderer;
List <int> submeshIndices = rendererData.submeshIndices;
submeshIndices.Clear();
submeshIndices.AddRange(sSubmeshIndices);
sRendererData.Add(rendererData);
}
sSubmeshIndices.Clear();
}
sRenderers.Clear();
// Return if transform t doesn't have any children
int childCount = t.childCount;
if (childCount == 0)
{
return;
}
// Recursively cache renderers on all child GameObjects
for (int i = 0; i < childCount; i++)
{
Transform childTransform = t.GetChild(i);
// Do not cache Renderers of this childTransform in case it has it's own Highlighter component
HighlighterCore h = childTransform.GetComponent <HighlighterCore>();
if (h != null)
{
continue;
}
GrabRenderers(childTransform);
}
}
private void GeneratRenderersData()
{
Renderer[] childs;
if (ChangeChildMaterials)
{
childs = gameObject.GetComponentsInChildren <Renderer> () as Renderer[];
}
else
{
childs = gameObject.GetComponents <Renderer> () as Renderer[];
}
Renderers = new RendererData[childs.Length];
for (int i = 0; i < childs.Length; i++)
{
Renderers[i] = new RendererData(childs[i], MaterialOn);
}
}
// This method defines how renderers are initialized
private void UpdateRenderers()
{
if (isDirty)
{
isDirty = false;
ClearRenderers();
// Find all renderers which should be highlighted with this HighlighterCore component instance
GrabRenderers(tr);
// Cache found renderers
for (int i = 0, imax = sRendererData.Count; i < imax; i++)
{
RendererData rendererData = sRendererData[i];
GameObject rg = rendererData.renderer.gameObject;
HighlighterRenderer renderer = rg.GetComponent <HighlighterRenderer>();
if (renderer == null)
{
renderer = rg.AddComponent <HighlighterRenderer>();
}
renderer.isAlive = true;
renderer.Initialize(opaqueMaterial, transparentShader, rendererData.submeshIndices);
renderer.SetOverlay(cachedOverlay);
renderer.SetColor(cachedColor);
highlightableRenderers.Add(renderer);
}
// Release RendererData instances
for (int i = 0; i < sRendererData.Count; i++)
{
ReleaseRendererDataInstance(sRendererData[i]);
}
sRendererData.Clear();
}
}
private static void InternalExport(IndexRenderersData indexRenderersData, Stack <int> indices, Transform rootTransform, bool includeDeactive)
{
int childCount = rootTransform.childCount;
for (int iChild = 0; iChild < childCount; iChild++)
{
Transform iterChild = rootTransform.GetChild(iChild);
GameObject iterGameObject = iterChild.gameObject;
if (!includeDeactive &&
!iterGameObject.activeSelf)
{
continue;
}
indices.Push(iChild);
if (Common.Utility.ObjectUtility.HasStaticEditorFlag(iterGameObject
#if UNITY_2019_1_OR_NEWER
, StaticEditorFlags.ContributeGI
#else
, UnityEditor.StaticEditorFlags.LightmapStatic
#endif
))
{
UnityEngine.Renderer iterRenderer = iterGameObject.GetComponent <UnityEngine.Renderer>();
if (iterRenderer)
{
indexRenderersData.RenderersIndices.Add(new IndexRenderersData.Indices(indices));
RendererData rendererData = new RendererData();
rendererData.Export(iterRenderer);
indexRenderersData.RenderersData.Add(rendererData);
}
}
InternalExport(indexRenderersData, indices, iterChild, includeDeactive);
indices.Pop();
}
}
private void Awake()
{
SpriteRenderer[] spriteRenderers = GetComponentsInChildren <SpriteRenderer>();
foreach (SpriteRenderer sr in spriteRenderers)
{
RendererData rendererData = new RendererData()
{
Renderer = sr,
Size = sr.size
};
m_RendererDatas.Add(rendererData);
}
BoxCollider2D[] boxCollider2Ds = GetComponentsInChildren <BoxCollider2D>();
foreach (BoxCollider2D bc in boxCollider2Ds)
{
ColliderData colliderData = new ColliderData()
{
Collider = bc,
size = bc.size
};
m_ColliderDatas.Add(colliderData);
}
}
protected void Awake()
{
this.Tm = base.transform;
this.TransformAnimation = GameObjectExtensions.AddOrGetComponent <TransformAnimation>(base.gameObject);
for (int i = 0; i < this.CoinRenderers.Count; i++)
{
RendererData item = new RendererData();
item.Transform = this.CoinRenderers[i].transform;
item.SpriterRenderer = this.CoinRenderers[i];
item.TransformAnimation = GameObjectExtensions.AddOrGetComponent <TransformAnimation>(item.SpriterRenderer.gameObject);
item.LocalScale = item.Transform.localScale;
item.Billboard = false;
this.m_coinRenderers.Add(item);
}
for (int j = 0; j < this.DiamondRenderers.Count; j++)
{
RendererData data2 = new RendererData();
data2.Transform = this.DiamondRenderers[j].transform;
data2.SpriterRenderer = this.DiamondRenderers[j];
data2.TransformAnimation = GameObjectExtensions.AddOrGetComponent <TransformAnimation>(data2.SpriterRenderer.gameObject);
data2.LocalScale = data2.Transform.localScale;
data2.Billboard = false;
this.m_diamondRenderers.Add(data2);
}
for (int k = 0; k < this.XpRenderers.Count; k++)
{
RendererData data3 = new RendererData();
data3.Transform = this.XpRenderers[k].transform;
data3.SpriterRenderer = this.XpRenderers[k];
data3.TransformAnimation = GameObjectExtensions.AddOrGetComponent <TransformAnimation>(data3.SpriterRenderer.gameObject);
data3.LocalScale = data3.Transform.localScale;
data3.Billboard = true;
this.m_xpRenderers.Add(data3);
}
this.m_originalChestSpriteSortingOrder = this.Chest2dRenderer.sortingOrder;
}
void Reset()
{
string tankName = "ii";
RendererDataArr = new List <RendererData>();
#region attach
RendererData attachRd = new RendererData();
string attach = "attach";
attachRd.TargetRendererName = attach;
attachRd.ShaderName = "Tank/Attach";
attachRd.TextureProperty.Add(
new StringKeyValue("_MainTex", string.Format("{0}_{1}_{2}", tankName, attach, "d")));
attachRd.FloatProperty.Add(new FloatKeyValue("_Metallic", 0.5f));
attachRd.FloatProperty.Add(new FloatKeyValue("_Smoothness", 1));
#endregion
#region body
RendererData bodyRd = new RendererData();
string body = "body";
bodyRd.TargetRendererName = body;
bodyRd.ShaderName = "Tank/Body";
bodyRd.TextureProperty.Add(new StringKeyValue("_Splat0", string.Format("{0}_{1}_{2}", "common", "splat", "paint01")));
bodyRd.TextureProperty.Add(new StringKeyValue("_NormalMap0",
string.Format("{0}_{1}_{2}", "common", "splat", "paint01n")));
bodyRd.FloatProperty.Add(new FloatKeyValue("_Tiling0", 6));
bodyRd.FloatProperty.Add(new FloatKeyValue("_Metallic0", .65f));
bodyRd.FloatProperty.Add(new FloatKeyValue("_Smoothness0", .8f));
bodyRd.TextureProperty.Add(new StringKeyValue("_Splat1", string.Format("{0}_{1}_{2}", "common", "splat", "rust01")));
bodyRd.FloatProperty.Add(new FloatKeyValue("_Tiling1", 8));
bodyRd.FloatProperty.Add(new FloatKeyValue("_Metallic1", .7f));
bodyRd.FloatProperty.Add(new FloatKeyValue("_Smoothness1", .8f));
bodyRd.TextureProperty.Add(new StringKeyValue("_Splat2", string.Format("{0}_{1}_{2}", "common", "splat", "metal01")));
bodyRd.FloatProperty.Add(new FloatKeyValue("_Tiling2", 7));
bodyRd.FloatProperty.Add(new FloatKeyValue("_Metallic2", .9f));
bodyRd.FloatProperty.Add(new FloatKeyValue("_Smoothness2", 1));
bodyRd.TextureProperty.Add(new StringKeyValue("_Splat3", string.Format("{0}_{1}_{2}", "common", "splat", "dirt01")));
bodyRd.FloatProperty.Add(new FloatKeyValue("_Tiling3", 8));
bodyRd.FloatProperty.Add(new FloatKeyValue("_Metallic3", 0));
bodyRd.FloatProperty.Add(new FloatKeyValue("_Smoothness3", .5f));
bodyRd.TextureProperty.Add(new StringKeyValue("_MainTex", string.Format("{0}_{1}_{2}", tankName, body, "m")));
bodyRd.TextureProperty.Add(new StringKeyValue("_Ao", string.Format("{0}_{1}_{2}", tankName, body, "a")));
#endregion
#region track
RendererData trackRd = new RendererData();
string track = "track";
trackRd.TargetRendererName = track;
trackRd.ShaderName = "Tank/Track";
trackRd.TextureProperty.Add(new StringKeyValue("_MainTex",
string.Format("{0}_{1}_{2}", tankName, track, "d")));
trackRd.TextureProperty.Add(new StringKeyValue("_Normal",
string.Format("{0}_{1}_{2}", tankName, track, "n")));
trackRd.TextureProperty.Add(new StringKeyValue("_MainTex",
string.Format("{0}_{1}_{2}", tankName, track, "d")));
#endregion
#region wheel
RendererData wheelRd = new RendererData();
string wheel = "wheel";
wheelRd.TargetRendererName = wheel;
wheelRd.ShaderName = "Tank/Wheel";
wheelRd.TextureProperty.Add(
new StringKeyValue("_Mask", string.Format("{0}_{1}_{2}", tankName, wheel, "m")));
wheelRd.TextureProperty.Add(
new StringKeyValue("_Paint", string.Format("{0}_{1}_{2}", "common", "splat", "paint01")));
wheelRd.FloatProperty.Add(new FloatKeyValue("_PaintTiling", 1));
wheelRd.TextureProperty.Add(
new StringKeyValue("_MainTex", string.Format("{0}_{1}_{2}", tankName, wheel, "d")));
wheelRd.TextureProperty.Add(new StringKeyValue("_Normal",
string.Format("{0}_{1}_{2}", tankName, wheel, "n")));
wheelRd.FloatProperty.Add(new FloatKeyValue("_Metallic", 0.5f));
wheelRd.FloatProperty.Add(new FloatKeyValue("_Smoothness", 1));
#endregion
#region shadow
RendererData shadowRd = new RendererData();
string shadow = "shadow";
shadowRd.TargetRendererName = shadow;
shadowRd.ShaderName = "Tank/Shadow";
shadowRd.TextureProperty.Add(new StringKeyValue("_MainTex",
string.Format("{0}_{1}_{2}", tankName, shadow, "d")));
shadowRd.FloatProperty.Add(new FloatKeyValue("_Strength", 0.6f));
shadowRd.FloatProperty.Add(new FloatKeyValue("_Power", 0.5f));
#endregion
RendererDataArr.Add(attachRd);
RendererDataArr.Add(bodyRd);
RendererDataArr.Add(trackRd);
RendererDataArr.Add(wheelRd);
RendererDataArr.Add(shadowRd);
}
public void AddRenderObject(RenderObject obj)
{
//Si sprite on fait 2 triangles
if (obj.Sprite != null)
{
var pos = obj.Position[0];
var halfSize = obj.Size / 2;
var pos1 = pos - halfSize;
var pos2 = new Vector2(pos.X - halfSize.X, pos.Y + halfSize.Y);
var pos3 = new Vector2(pos.X + halfSize.X, pos.Y - halfSize.Y);
var pos4 = pos + halfSize;
//Triangle 1
var data = new RendererData();
data.Color = obj.Color;
data.Position = pos1;
data.TextureCoordinates = new Vector2(obj.Sprite.Coordinates.MinX, obj.Sprite.Coordinates.MaxY);
m_datas.Add(data);
data = new RendererData();
data.Color = obj.Color;
data.Position = pos2;
data.TextureCoordinates = new Vector2(obj.Sprite.Coordinates.MinX, obj.Sprite.Coordinates.MinY);
m_datas.Add(data);
data = new RendererData();
data.Color = obj.Color;
data.Position = pos3;
data.TextureCoordinates = new Vector2(obj.Sprite.Coordinates.MaxX, obj.Sprite.Coordinates.MaxY);
m_datas.Add(data);
//Triangle 2
data = new RendererData();
data.Color = obj.Color;
data.Position = pos2;
data.TextureCoordinates = new Vector2(obj.Sprite.Coordinates.MinX, obj.Sprite.Coordinates.MinY);
m_datas.Add(data);
data = new RendererData();
data.Color = obj.Color;
data.Position = pos3;
data.TextureCoordinates = new Vector2(obj.Sprite.Coordinates.MaxX, obj.Sprite.Coordinates.MaxY);
m_datas.Add(data);
data = new RendererData();
data.Color = obj.Color;
data.Position = pos4;
data.TextureCoordinates = new Vector2(obj.Sprite.Coordinates.MaxX, obj.Sprite.Coordinates.MinY);
m_datas.Add(data);
}
else
{
var data = new RendererData();
data.Color = obj.Color;
data.Position = obj.Position[0];
m_datas.Add(data);
data = new RendererData();
data.Color = obj.Color;
data.Position = obj.Position[1];
m_datas.Add(data);
data = new RendererData();
data.Color = obj.Color;
data.Position = obj.Position[2];
m_datas.Add(data);
}
}
public Destroyer(RendererData data) : base(data)
{
Enabled = true;
}
private void GeneratRenderersData()
{
Renderer[] childs;
if ( ChangeChildMaterials )
{
childs = gameObject.GetComponentsInChildren<Renderer> () as Renderer[];
}
else
{
childs = gameObject.GetComponents<Renderer> () as Renderer[];
}
Renderers = new RendererData[childs.Length];
for ( int i = 0; i < childs.Length; i++ )
{
Renderers[i] = new RendererData ( childs[i], MaterialOn );
}
}
public void AddRendererData(RendererData data)
{
RenderersList.Add(data);
}
static GameObjectData AssessGameObject(GameObject go)
{
if (go == null)
{
return(null);
}
GameObjectData gd = new GameObjectData();
gd.gameobject = go;
foreach (Renderer r in go.GetComponentsInChildren <Renderer>(true))
{
Mesh mesh = null;
if (r is SkinnedMeshRenderer)
{
mesh = (r as SkinnedMeshRenderer).sharedMesh;
}
else
{
MeshFilter mf = r.GetComponent <MeshFilter>();
if (mf != null)
{
mesh = mf.sharedMesh;
}
}
if (mesh == null)
{
continue;
}
RendererData rd = new RendererData();
rd.renderer = r;
gd.renderers.Add(rd);
Material[] mats = r.sharedMaterials;
Transform trans = r.transform;
vertices.Clear();
uvs.Clear();
mesh.GetVertices(vertices);
mesh.GetUVs(0, uvs);
for (int i = 0; i < mesh.subMeshCount; i++)
{
Material m = i < mats.Length ? mats[i] : null;
MaterialData md = new MaterialData();
md.material = m;
rd.materials.Add(md);
if (m != null)
{
string mp = AssetDatabase.GetAssetPath(m);
if (string.IsNullOrEmpty(mp))
{
continue;
}
foreach (string tp in AssetDatabase.GetDependencies(mp, false))
{
Texture tex = AssetDatabase.LoadAssetAtPath <Texture>(tp);
if (tex == null)
{
continue;
}
TextureData td = new TextureData();
td.texture = tex;
md.textures.Add(td);
}
}
if (uvs.Count > 0)
{
md.duv_min = float.PositiveInfinity;
float weight = 0f;
triangles.Clear();
mesh.GetTriangles(triangles, i, false);
int index = 0;
//Debug.LogError(triangles.Count);
while (index < triangles.Count)
{
int i0 = triangles[index++];
int i1 = triangles[index++];
int i2 = triangles[index++];
Vector3 v0 = vertices[i0];
Vector3 v1 = vertices[i1];
Vector3 v2 = vertices[i2];
Vector2 uv0 = uvs[i0];
Vector2 uv1 = uvs[i1];
Vector2 uv2 = uvs[i2];
//Debug.LogWarningFormat("{0} - {1} - {2}", v0, v1, v2);
v0 = trans.TransformPoint(v0);
v1 = trans.TransformPoint(v1);
v2 = trans.TransformPoint(v2);
//Debug.LogWarningFormat("{0} - {1} - {2}", v0, v1, v2);
//Debug.LogWarningFormat("{0} - {1} - {2}", uv0, uv1, uv2);
float dis0 = (v1 - v0).magnitude;
float dis1 = (v2 - v1).magnitude;
float dis2 = (v0 - v2).magnitude;
float duv0 = (uv1 - uv0).magnitude / dis0;
float duv1 = (uv2 - uv1).magnitude / dis1;
float duv2 = (uv0 - uv2).magnitude / dis2;
float s = 0.25f * Mathf.Sqrt((dis0 + dis1 + dis2) * (dis0 + dis1 - dis2) * (dis0 + dis2 - dis1) * (dis1 + dis2 - dis0));
md.duv_min = Mathf.Min(md.duv_min, duv0);
md.duv_min = Mathf.Min(md.duv_min, duv1);
md.duv_min = Mathf.Min(md.duv_min, duv2);
md.duv_max = Mathf.Max(md.duv_max, duv0);
md.duv_max = Mathf.Max(md.duv_max, duv1);
md.duv_max = Mathf.Max(md.duv_max, duv2);
md.duv_avg += (duv0 + duv1 + duv2) * s;
weight += s + s + s;
}
md.duv_avg /= weight;
}
//Debug.LogError(md.duv_min);
//Debug.LogWarning(md.duv_max);
//Debug.LogWarning(md.duv_avg);
//Debug.Log(weight);
}
}
return(gd);
}
