private void Update()
{
if ((this.prefabRendering != this.prefab) || !this.oi)
{
if (this.prefabRendering != null)
{
this.renderer = null;
}
if (this.prefab != null)
{
this.renderer = PrefabRenderer.GetOrCreateRender(this.prefab);
}
this.prefabRendering = this.prefab;
this.oi = true;
this.ApplyOverrides();
}
if (this.renderer == null)
{
Debug.Log("None", this);
}
else
{
this.renderer.Render(null, base.transform.localToWorldMatrix, null, this.overrideMaterials);
}
}
public virtual void RenderDeployPreview(Vector3 point, Quaternion rot, TransCarrier carrier)
{
if (this._aimGizmo != null)
{
this._aimGizmo.rotation = rot;
this._aimGizmo.position = point;
}
if (this._prefabRenderer == null)
{
DeployableObject objectToPlace = this.datablock.ObjectToPlace;
if (!objectToPlace)
{
return;
}
this._prefabRenderer = PrefabRenderer.GetOrCreateRender(objectToPlace.gameObject);
}
Material material = (T)this.datablock.overrideMat;
if (!material)
{
PrefabRenderer prefabRenderer = this._prefabRenderer;
Camera camera = MountedCamera.main.camera;
T t = this.datablock;
prefabRenderer.Render(camera, Matrix4x4.TRS(point, rot, t.ObjectToPlace.transform.localScale), this._aimGizmo.propertyBlock, null);
}
else
{
PrefabRenderer prefabRenderer1 = this._prefabRenderer;
Camera camera1 = MountedCamera.main.camera;
T t1 = this.datablock;
prefabRenderer1.RenderOneMaterial(camera1, Matrix4x4.TRS(point, rot, t1.ObjectToPlace.transform.localScale), this._aimGizmo.propertyBlock, material);
}
if (this._aimGizmo != null)
{
bool flag = false;
if (carrier)
{
Renderer renderer = carrier.renderer;
if (renderer is MeshRenderer && renderer && renderer.enabled)
{
flag = true;
this._aimGizmo.carrierRenderer = (MeshRenderer)renderer;
}
}
if (!flag)
{
this._aimGizmo.carrierRenderer = null;
}
}
}
public static PrefabRenderer GetOrCreateRender(GameObject prefab)
{
PrefabRenderer target;
bool flag;
WeakReference weakReference;
if (!prefab)
{
return(null);
}
while (prefab.transform.parent)
{
prefab = prefab.transform.parent.gameObject;
}
int instanceID = prefab.GetInstanceID();
object @lock = PrefabRenderer.Runtime.Lock;
Monitor.Enter(@lock);
try
{
if (!PrefabRenderer.Runtime.Register.TryGetValue(instanceID, out weakReference))
{
target = null;
}
else
{
target = (PrefabRenderer)weakReference.Target;
}
flag = target != null;
if (!flag)
{
target = new PrefabRenderer(instanceID);
}
}
finally
{
Monitor.Exit(@lock);
}
if (!flag)
{
target.prefab = prefab;
target.Refresh();
}
return(target);
}
public virtual void RenderDeployPreview(Vector3 point, Quaternion rot, TransCarrier carrier)
{
if (this._aimGizmo != null)
{
this._aimGizmo.rotation = rot;
this._aimGizmo.position = point;
}
if (this._prefabRenderer == null)
{
DeployableObject objectToPlace = base.datablock.ObjectToPlace;
if (objectToPlace == null)
{
return;
}
this._prefabRenderer = PrefabRenderer.GetOrCreateRender(objectToPlace.gameObject);
}
Material overrideMat = base.datablock.overrideMat;
if (overrideMat != null)
{
this._prefabRenderer.RenderOneMaterial(MountedCamera.main.camera, Matrix4x4.TRS(point, rot, base.datablock.ObjectToPlace.transform.localScale), this._aimGizmo.propertyBlock, overrideMat);
}
else
{
this._prefabRenderer.Render(MountedCamera.main.camera, Matrix4x4.TRS(point, rot, base.datablock.ObjectToPlace.transform.localScale), this._aimGizmo.propertyBlock, null);
}
if (this._aimGizmo != null)
{
bool flag = false;
if (carrier != null)
{
Renderer renderer = carrier.renderer;
if (((renderer is MeshRenderer) && (renderer != null)) && renderer.enabled)
{
flag = true;
this._aimGizmo.carrierRenderer = (MeshRenderer)renderer;
}
}
if (!flag)
{
this._aimGizmo.carrierRenderer = null;
}
}
}
public static PrefabRenderer GetOrCreateRender(GameObject prefab)
{
PrefabRenderer target;
bool flag;
if (prefab == null)
{
return(null);
}
while (prefab.transform.parent != null)
{
prefab = prefab.transform.parent.gameObject;
}
int instanceID = prefab.GetInstanceID();
object @lock = Runtime.Lock;
lock (@lock)
{
WeakReference reference;
if (Runtime.Register.TryGetValue(instanceID, out reference))
{
target = (PrefabRenderer)reference.Target;
}
else
{
target = null;
}
flag = target != null;
if (!flag)
{
target = new PrefabRenderer(instanceID);
}
}
if (!flag)
{
target.prefab = prefab;
target.Refresh();
}
return(target);
}
public virtual void RenderDeployPreview(Vector3 point, Quaternion rot)
{
if (this._prefabRenderer == null)
{
StructureComponent structureToPlacePrefab = base.datablock.structureToPlacePrefab;
if (structureToPlacePrefab == null)
{
return;
}
this._prefabRenderer = PrefabRenderer.GetOrCreateRender(structureToPlacePrefab.gameObject);
this._materialProps = new MaterialPropertyBlock();
}
Material overrideMat = base.datablock.overrideMat;
if (overrideMat != null)
{
this._prefabRenderer.RenderOneMaterial(MountedCamera.main.camera, Matrix4x4.TRS(point, rot, Vector3.one), this._materialProps, overrideMat);
}
else
{
this._prefabRenderer.Render(MountedCamera.main.camera, Matrix4x4.TRS(point, rot, Vector3.one), this._materialProps, null);
}
}
public void Refresh()
{
PrefabRenderer renderer = this;
Transform transform = this.prefab.transform;
HashSet <Material> set = new HashSet <Material>();
HashSet <Mesh> set2 = new HashSet <Mesh>();
List <Material[]> list = new List <Material[]>();
List <Mesh> list2 = new List <Mesh>();
int capacity = 0;
Renderer[] componentsInChildren = this.prefab.GetComponentsInChildren <Renderer>(true);
int size = 0;
for (int i = 0; i < componentsInChildren.Length; i++)
{
Renderer renderer2 = componentsInChildren[i];
if ((((renderer2 != null) && renderer2.enabled) && !renderer2.name.EndsWith("-lod", StringComparison.InvariantCultureIgnoreCase)) && !renderer2.name.EndsWith("_LOD_LOWEST", StringComparison.InvariantCultureIgnoreCase))
{
if (renderer2 is MeshRenderer)
{
componentsInChildren[size++] = renderer2;
Mesh sharedMesh = renderer2.GetComponent <MeshFilter>().sharedMesh;
if ((sharedMesh != null) && set2.Add(sharedMesh))
{
capacity++;
}
list2.Add(sharedMesh);
}
else
{
if (!(renderer2 is SkinnedMeshRenderer))
{
continue;
}
componentsInChildren[size++] = renderer2;
Mesh item = ((SkinnedMeshRenderer)renderer2).sharedMesh;
if ((item != null) && set2.Add(item))
{
capacity++;
}
list2.Add(item);
}
Material[] sharedMaterials = renderer2.sharedMaterials;
list.Add(sharedMaterials);
set.UnionWith(sharedMaterials);
}
}
for (int j = size; j < componentsInChildren.Length; j++)
{
componentsInChildren[j] = null;
}
int count = set.Count;
int num6 = ((count % 0x20) <= 0) ? (count / 0x20) : ((count / 0x20) + 1);
DoNotCareResize <int>(ref renderer.skipBits, num6);
for (int k = 0; k < num6; k++)
{
this.skipBits[k] = 0;
}
Dictionary <Material, int> dictionary = new Dictionary <Material, int>(count);
Dictionary <Mesh, int> dictionary2 = new Dictionary <Mesh, int>(capacity);
DoNotCareResize <Material>(ref renderer.originalMaterials, count);
int index = 0;
foreach (Material material in set)
{
if (material.GetTag("IgnorePrefabRenderer", false, "False") == "True")
{
this.skipBits[index / 0x20] |= ((int)1) << (index % 0x20);
}
renderer.originalMaterials[index] = material;
dictionary[material] = index++;
}
DoNotCareResize <Mesh>(ref renderer.originalMeshes, capacity);
int num9 = 0;
foreach (Mesh mesh3 in set2)
{
renderer.originalMeshes[num9] = mesh3;
dictionary2[mesh3] = num9++;
}
DoNotCareResize <MeshRender>(ref renderer.meshes, size);
for (int m = 0; m < size; m++)
{
Renderer renderer3 = componentsInChildren[m];
Material[] materialArray2 = list[m];
int[] materials = new int[materialArray2.Length];
for (int n = 0; n < materialArray2.Length; n++)
{
materials[n] = dictionary[materialArray2[n]];
}
renderer.meshes[m].Set(dictionary2[list2[m]], materials, renderer3.transform.localToWorldMatrix * transform.worldToLocalMatrix, renderer3.gameObject.layer, renderer3.castShadows, renderer3.receiveShadows);
}
}
public void Refresh()
{
Renderer renderer;
PrefabRenderer prefabRenderer = this;
Transform transforms = this.prefab.transform;
HashSet <Material> materials = new HashSet <Material>();
HashSet <Mesh> meshes = new HashSet <Mesh>();
List <Material[]> materialArrays = new List <Material[]>();
List <Mesh> meshes1 = new List <Mesh>();
int num = 0;
Renderer[] componentsInChildren = this.prefab.GetComponentsInChildren <Renderer>(true);
int num1 = 0;
for (int i = 0; i < (int)componentsInChildren.Length; i++)
{
renderer = componentsInChildren[i];
if (renderer && renderer.enabled && !renderer.name.EndsWith("-lod", StringComparison.InvariantCultureIgnoreCase) && !renderer.name.EndsWith("_LOD_LOWEST", StringComparison.InvariantCultureIgnoreCase))
{
if (!(renderer is MeshRenderer))
{
if (renderer is SkinnedMeshRenderer)
{
goto Label1;
}
goto Label0;
}
else
{
int num2 = num1;
num1 = num2 + 1;
componentsInChildren[num2] = renderer;
Mesh component = renderer.GetComponent <MeshFilter>().sharedMesh;
if (component && meshes.Add(component))
{
num++;
}
meshes1.Add(component);
}
Label2:
Material[] materialArray = renderer.sharedMaterials;
materialArrays.Add(materialArray);
materials.UnionWith(materialArray);
}
Label0:
}
for (int j = num1; j < (int)componentsInChildren.Length; j++)
{
componentsInChildren[j] = null;
}
int count = materials.Count;
int num3 = (count % 32 <= 0 ? count / 32 : count / 32 + 1);
PrefabRenderer.DoNotCareResize <int>(ref prefabRenderer.skipBits, num3);
for (int k = 0; k < num3; k++)
{
this.skipBits[k] = 0;
}
Dictionary <Material, int> materials1 = new Dictionary <Material, int>(count);
Dictionary <Mesh, int> meshes2 = new Dictionary <Mesh, int>(num);
PrefabRenderer.DoNotCareResize <Material>(ref prefabRenderer.originalMaterials, count);
int num4 = 0;
foreach (Material material in materials)
{
if (material.GetTag("IgnorePrefabRenderer", false, "False") == "True")
{
this.skipBits[num4 / 32] = this.skipBits[num4 / 32] | 1 << (num4 % 32 & 31 & 31);
}
prefabRenderer.originalMaterials[num4] = material;
int num5 = num4;
num4 = num5 + 1;
materials1[material] = num5;
}
PrefabRenderer.DoNotCareResize <Mesh>(ref prefabRenderer.originalMeshes, num);
int num6 = 0;
foreach (Mesh mesh in meshes)
{
prefabRenderer.originalMeshes[num6] = mesh;
int num7 = num6;
num6 = num7 + 1;
meshes2[mesh] = num7;
}
PrefabRenderer.DoNotCareResize <PrefabRenderer.MeshRender>(ref prefabRenderer.meshes, num1);
for (int l = 0; l < num1; l++)
{
Renderer renderer1 = componentsInChildren[l];
Material[] item = materialArrays[l];
int[] numArray = new int[(int)item.Length];
for (int m = 0; m < (int)item.Length; m++)
{
numArray[m] = materials1[item[m]];
}
prefabRenderer.meshes[l].Set(meshes2[meshes1[l]], numArray, renderer1.transform.localToWorldMatrix * transforms.worldToLocalMatrix, renderer1.gameObject.layer, renderer1.castShadows, renderer1.receiveShadows);
}
return;
Label1:
int num8 = num1;
num1 = num8 + 1;
componentsInChildren[num8] = renderer;
Mesh mesh1 = ((SkinnedMeshRenderer)renderer).sharedMesh;
if (mesh1 && meshes.Add(mesh1))
{
num++;
}
meshes1.Add(mesh1);
goto Label2;
}
private void Update()
{
if (this.prefabRendering != this.prefab || !this.oi)
{
if (this.prefabRendering)
{
this.renderer = null;
}
if (this.prefab)
{
this.renderer = PrefabRenderer.GetOrCreateRender(this.prefab);
}
this.prefabRendering = this.prefab;
this.oi = true;
this.ApplyOverrides();
}
if (this.renderer == null)
{
Debug.Log("None", this);
return;
}
this.renderer.Render(null, base.transform.localToWorldMatrix, null, this.overrideMaterials);
}
