public void ApplyRendererInfo(RendererInfo[] infos)
{
try
{
Terrain terrain = FindObjectOfType <Terrain>();
int i = 0;
if (terrain != null)
{
terrain.lightmapIndex = infos[i].lightmapIndex;
terrain.lightmapScaleOffset = infos[i].lightmapOffsetScale;
i++;
}
for (int j = i; j < infos.Length; j++)
{
RendererInfo info = infos[j];
//if (info.renderer == null)
//continue;
info.renderer.lightmapIndex = infos[j].lightmapIndex;
if (!info.renderer.isPartOfStaticBatch)
{
info.renderer.lightmapScaleOffset = infos[j].lightmapOffsetScale;
}
if (info.renderer.isPartOfStaticBatch && verbose == true && Application.isEditor)
{
Debug.Log("Object " + info.renderer.gameObject.name + " is part of static batch, skipping lightmap offset and scale.");
}
}
}
catch (Exception e)
{
Debug.LogError("Error in ApplyRendererInfo:" + e.GetType().ToString());
}
}
private void InternalRegisterAttributeRenderer(string rendererTypeName, string attributeTypeName, string area)
{
string key = area;
if ((key == null) || (key.Trim().Length == 0))
{
key = GLOBAL_RENDERER_KEY;
}
IList rendererList = (IList)_area2renderers[key];
if (rendererList == null)
{
rendererList = new ArrayList();
_area2renderers[key] = rendererList;
}
RendererInfo rendererInfo = new RendererInfo(rendererTypeName, attributeTypeName);
rendererList.Add(rendererInfo);
if (!_attributeRenderers.Contains(rendererTypeName))
{
_attributeRenderers.Add(rendererTypeName);
}
}
static void GenerateLightmapInfo(GameObject root, List <RendererInfo> newRendererInfos, List <Texture2D> newLightmapsLight, List <Texture2D> newLightmapsDir, LightmapsMode newLightmapsMode)
{
var renderers = FindObjectsOfType(typeof(MeshRenderer));
Debug.Log("stored info for " + renderers.Length + " meshrenderers");
foreach (MeshRenderer renderer in renderers)
{
if (renderer.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.renderer = renderer;
info.lightmapOffsetScale = renderer.lightmapScaleOffset;
Texture2D lightmaplight = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapLight;
info.lightmapIndex = newLightmapsLight.IndexOf(lightmaplight);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = newLightmapsLight.Count;
newLightmapsLight.Add(lightmaplight);
}
if (newLightmapsMode != LightmapsMode.NonDirectional)
{
Texture2D lightmapdir = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapDir;
info.lightmapIndex = newLightmapsDir.IndexOf(lightmapdir);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = newLightmapsDir.Count;
newLightmapsDir.Add(lightmapdir);
}
}
newRendererInfos.Add(info);
}
}
}
public void SaveLightmap()
{
m_RendererInfo.Clear();
var renderers = GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer r in renderers)
{
if (r.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.renderer = r;
info.lightmapOffsetScale = r.lightmapScaleOffset;
info.lightmapIndex = r.lightmapIndex;
// Texture2D lightmap = LightmapSettings.lightmaps[r.lightmapIndex].lightmapFar;
//
// info.lightmapIndex = m_Lightmaps.IndexOf(lightmap);
// if (info.lightmapIndex == -1) {
// info.lightmapIndex = m_Lightmaps.Count;
// m_Lightmaps.Add(lightmap);
// }
m_RendererInfo.Add(info);
}
}
}
static void GenerateLightmapInfo(GameObject root, List <RendererInfo> rendererInfos, List <Texture2D> lightmaps)
{
var renderers = root.GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer renderer in renderers)
{
if (renderer.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.renderer = renderer;
info.lightmapOffsetScale = renderer.lightmapScaleOffset;
Texture2D lightmap = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapColor;
info.lightmapIndex = lightmaps.IndexOf(lightmap);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = lightmaps.Count;
lightmaps.Add(lightmap);
}
rendererInfos.Add(info);
}
}
}
/// <summary>
/// 帧动画更新
/// </summary>
public void LateUpdate()
{
for (int index = 0; index < m_RendererInfo.Count; index++)
{
RendererInfo rendererInfo = m_RendererInfo[index];
if (rendererInfo.placeholder.isAnimate)
{
rendererInfo.timeline += Time.deltaTime;
if (rendererInfo.timeline >= (1 / (float)rendererInfo.placeholder.rate))
{
int frame = rendererInfo.curFrame + 1;
string animateName = rendererInfo.placeholder.animateName;
RichTextAnimate richTextAnimate = textSpriteAsset.GetAnimateListByName(animateName);
List <TexturePackSprite> sprites = richTextAnimate.spriteList;
if (frame >= sprites.Count)
{
frame = 0;
}
GenerateNewUv(sprites[frame], ref rendererInfo.uvInfo);
rendererInfo.timeline = 0.0f;
rendererInfo.curFrame = frame;
PlayAnimate();
}
}
}
}
public void SaveLightmap(Transform parent)
{
if (AllRendererInfo == null)
{
AllRendererInfo = new List <RendererInfo>();
}
AllRendererInfo.Clear();
Renderer[] renderers = GetComponentsInChildren <MeshRenderer>(true);
if (renderers != null && renderers.Length > 0)
{
for (int i = 0; i < renderers.Length; i++)
{
Renderer renderer = renderers[i];
if (renderer == null)
{
continue;
}
RendererInfo info = new RendererInfo();
info.renderer = renderer;
info.lightmapIndex = renderer.lightmapIndex;
info.lightmapOffsetScale = renderer.lightmapScaleOffset;
info.UpdateRootPath(parent);
AllRendererInfo.Add(info);
}
}
}
static void GenerateLightmapInfo(string scenePath, string resourcePath, GameObject root, List <RendererInfo> rendererInfos, List <Texture2D> lightmaps, List <Texture2D> lightmaps2)
{
var renderers = root.GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer renderer in renderers)
{
if (renderer.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.renderer = renderer;
info.lightmapOffsetScale = renderer.lightmapScaleOffset;
Texture2D lightmap = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapColor;
Texture2D lightmap2 = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapDir;
int sceneLightmapIndex = AddLightmap(scenePath, resourcePath, renderer.lightmapIndex, lightmap, lightmap2);
info.lightmapIndex = lightmaps.IndexOf(sceneLightmaps[sceneLightmapIndex].lightmap0);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = lightmaps.Count;
lightmaps.Add(sceneLightmaps[sceneLightmapIndex].lightmap0);
lightmaps2.Add(sceneLightmaps[sceneLightmapIndex].lightmap1);
}
rendererInfos.Add(info);
}
}
}
/// <summary>
/// GoWrapper will cache all renderers of your gameobject on constructor.
/// If your gameobject change laterly, call this function to update the cache.
/// GoWrapper会在构造函数里查询你的gameobject所有的Renderer并保存。如果你的gameobject
/// 后续发生了改变，调用这个函数通知GoWrapper重新查询和保存。
/// </summary>
public void CacheRenderers()
{
if (_canvas != null)
{
return;
}
RecoverMaterials();
_renderers.Clear();
Renderer[] items = _wrapTarget.GetComponentsInChildren <Renderer>(true);
int cnt = items.Length;
_renderers.Capacity = cnt;
for (int i = 0; i < cnt; i++)
{
Renderer r = items[i];
Material[] mats = r.sharedMaterials;
RendererInfo ri = new RendererInfo()
{
renderer = r,
materials = mats,
sortingOrder = r.sortingOrder
};
_renderers.Add(ri);
}
_renderers.Sort((RendererInfo c1, RendererInfo c2) =>
{
return(c1.sortingOrder - c2.sortingOrder);
});
_shouldCloneMaterial = true;
}
/// <summary>
/// Draw the GUI elements for when there are no known renderers. (SearchInfo is not avaiable.)
/// </summary>
private void DrawBasic(Rect position, SerializedProperty property, bool hasLabel)
{
var props = new Props(property);
var rect = EditorGUIUtil.NextGuiElementPosition(position, 0, false);
EditorGUI.PropertyField(rect, props.renderer);
GUIContent[] labels;
if (props.renderer.objectReferenceValue)
{
if (m_RendererInfo == null)
{
m_RendererInfo = new RendererInfo();
}
var renderer = props.renderer.objectReferenceValue as Renderer;
if (m_RendererInfo.renderer != renderer)
{
m_RendererInfo.Update(renderer);
}
labels = m_RendererInfo.materialLabels;
}
else
{
labels = null;
}
rect = EditorGUIUtil.NextGuiElementPosition(rect);
DrawMaterials(rect, props.index, labels);
}
/// <summary>
/// 绑定数据
/// </summary>
public void Bind()
{
List <Texture2D> lightmapFars = new List <Texture2D>();
List <Texture2D> lightmapNears = new List <Texture2D>();
List <RendererInfo> rendererInfos = new List <RendererInfo>();
MeshRenderer[] rds = this.GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer rd in rds)
{
//排除没烘焙的物体，如非静态的
if (rd.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.lightmapOffsetScale = rd.lightmapScaleOffset;
info.renderer = rd;
Texture2D lightmapFar = GetLightmapAsset(rd.lightmapIndex, true);
Texture2D lightmapNear = GetLightmapAsset(rd.lightmapIndex, false);
info.lightmapIndex = lightmapFars.IndexOf(lightmapFar);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = lightmapFars.Count;
lightmapFars.Add(lightmapFar);
lightmapNears.Add(lightmapNear);
}
rendererInfos.Add(info);
}
}
this.m_LightmapFars = lightmapFars.ToArray();
this.m_LightmapNears = lightmapNears.ToArray();
this.m_RendererInfo = rendererInfos.ToArray();
}
public void SaveLightmap()
{
m_RendererInfo.Clear();
var renderers = GetComponentsInChildren<MeshRenderer>();
foreach (MeshRenderer r in renderers)
{
if (r.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.renderer = r;
info.lightmapOffsetScale = r.lightmapScaleOffset;
info.lightmapIndex = r.lightmapIndex;
// Texture2D lightmap = LightmapSettings.lightmaps[r.lightmapIndex].lightmapFar;
//
// info.lightmapIndex = m_Lightmaps.IndexOf(lightmap);
// if (info.lightmapIndex == -1) {
// info.lightmapIndex = m_Lightmaps.Count;
// m_Lightmaps.Add(lightmap);
// }
m_RendererInfo.Add(info);
}
}
}
static void ApplyRendererInfo (RendererInfo[] infos, int lightmapOffsetIndex)
{
for (int i=0;i<infos.Length;i++)
{
var info = infos[i];
info.renderer.lightmapIndex = info.lightmapIndex + lightmapOffsetIndex;
info.renderer.lightmapScaleOffset = info.lightmapOffsetScale;
}
}
static void GenerateLightmapInfo(GameObject root, List <RendererInfo> rendererInfos, List <Texture2D> lightmaps, List <Texture2D> lightmapsDir, List <Texture2D> shadowMasks, List <LightInfo> lightsInfo)
{
var renderers = root.GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer renderer in renderers)
{
if (renderer.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.renderer = renderer;
if (renderer.lightmapScaleOffset != Vector4.zero)
{
//1ibrium's pointed out this issue : https://docs.unity3d.com/ScriptReference/Renderer-lightmapIndex.html
if (renderer.lightmapIndex < 0 || renderer.lightmapIndex == 0xFFFE)
{
continue;
}
info.lightmapOffsetScale = renderer.lightmapScaleOffset;
Texture2D lightmap = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapColor;
Texture2D lightmapDir = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapDir;
Texture2D shadowMask = LightmapSettings.lightmaps[renderer.lightmapIndex].shadowMask;
info.lightmapIndex = lightmaps.IndexOf(lightmap);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = lightmaps.Count;
lightmaps.Add(lightmap);
lightmapsDir.Add(lightmapDir);
shadowMasks.Add(shadowMask);
}
rendererInfos.Add(info);
}
}
}
var lights = root.GetComponentsInChildren <Light>(true);
foreach (Light l in lights)
{
LightInfo lightInfo = new LightInfo();
lightInfo.light = l;
lightInfo.lightmapBaketype = (int)l.lightmapBakeType;
#if UNITY_2020_1_OR_NEWER
lightInfo.mixedLightingMode = (int)UnityEditor.Lightmapping.lightingSettings.mixedBakeMode;
#elif UNITY_2018_1_OR_NEWER
lightInfo.mixedLightingMode = (int)UnityEditor.LightmapEditorSettings.mixedBakeMode;
#else
lightInfo.mixedLightingMode = (int)l.bakingOutput.lightmapBakeType;
#endif
lightsInfo.Add(lightInfo);
}
}
void RecoverMaterials()
{
if (_materialsBackup.Count == 0)
{
return;
}
int cnt = _renderers.Count;
for (int i = 0; i < cnt; i++)
{
RendererInfo ri = _renderers[i];
if (ri.renderer == null)
{
continue;
}
Material[] mats = ri.materials;
if (mats == null)
{
continue;
}
int mcnt = mats.Length;
for (int j = 0; j < mcnt; j++)
{
Material mat = mats[j];
foreach (KeyValuePair <Material, Material> kv in _materialsBackup)
{
if (kv.Value == mat)
{
mats[j] = kv.Key;
}
}
}
if (customRecoverMaterials != null)
{
customRecoverMaterials.Invoke();
}
else
{
ri.renderer.sharedMaterials = mats;
}
}
foreach (KeyValuePair <Material, Material> kv in _materialsBackup)
{
Material.DestroyImmediate(kv.Value);
}
_materialsBackup.Clear();
}
void CloneMaterials()
{
_shouldCloneMaterial = false;
int cnt = _renderers.Count;
for (int i = 0; i < cnt; i++)
{
RendererInfo ri = _renderers[i];
Material[] mats = ri.materials;
if (mats == null)
{
continue;
}
bool shouldSetRQ = (ri.renderer is SkinnedMeshRenderer) || (ri.renderer is MeshRenderer);
int mcnt = mats.Length;
for (int j = 0; j < mcnt; j++)
{
Material mat = mats[j];
if (mat == null)
{
continue;
}
if (shouldSetRQ && mat.renderQueue != 3000) //Set the object rendering in Transparent Queue as UI objects
{
mat.renderQueue = 3000;
}
if (mat.HasProperty(ShaderConfig.ID_Stencil) || mat.HasProperty(ShaderConfig.ID_Stencil2) ||
mat.HasProperty(ShaderConfig.ID_ClipBox))
{
_supportMask = true;
}
//确保相同的材质不会复制两次
Material newMat;
if (!_materialsBackup.TryGetValue(mat, out newMat))
{
newMat = new Material(mat);
_materialsBackup[mat] = newMat;
}
mats[j] = newMat;
}
if (ri.renderer != null)
{
ri.renderer.sharedMaterials = mats;
}
}
}
void CloneMaterials()
{
_shouldCloneMaterial = false;
int cnt = _renderers.Count;
for (int i = 0; i < cnt; i++)
{
RendererInfo ri = _renderers[i];
Material[] mats = ri.materials;
if (mats == null)
{
continue;
}
bool shouldSetRQ = (ri.renderer is SkinnedMeshRenderer) || (ri.renderer is MeshRenderer);
int mcnt = mats.Length;
for (int j = 0; j < mcnt; j++)
{
Material mat = mats[j];
if (mat == null)
{
continue;
}
//确保相同的材质不会复制两次
Material newMat;
if (!_materialsBackup.TryGetValue(mat, out newMat))
{
newMat = new Material(mat);
_materialsBackup[mat] = newMat;
}
mats[j] = newMat;
if (shouldSetRQ && mat.renderQueue != 3000) //Set the object rendering in Transparent Queue as UI objects
{
newMat.renderQueue = 3000;
}
}
if (customCloneMaterials != null)
{
customCloneMaterials.Invoke(_materialsBackup);
}
else if (ri.renderer != null)
{
ri.renderer.sharedMaterials = mats;
}
}
}
public void ApplyDataRendererInfo(RendererInfo[] infos)
{
try
{
//TODO : find better way to handle terrain. This doesn't support multiple terrains.
Terrain terrain = FindObjectOfType <Terrain>();
int i = 0;
if (terrain != null)
{
terrain.lightmapIndex = infos[i].lightmapIndex;
terrain.lightmapScaleOffset = infos[i].lightmapScaleOffset;
i++;
}
var hashRendererPairs = new Dictionary <int, RendererInfo>();
//Fill with lighting scenario to load renderer infos
foreach (var info in infos)
{
hashRendererPairs.Add(info.transformHash, info);
}
//Find all renderers
var renderers = FindObjectsOfType <Renderer>();
//Apply stored scale and offset if transform and mesh hashes match
foreach (var render in renderers)
{
var infoToApply = new RendererInfo();
//int transformHash = render.gameObject.transform.position
if (hashRendererPairs.TryGetValue(GetStableHash(render.gameObject.transform), out infoToApply))
{
if (render.gameObject.name == infoToApply.name)
{
render.lightmapIndex = infoToApply.lightmapIndex;
render.lightmapScaleOffset = infoToApply.lightmapScaleOffset;
}
}
}
}
catch (Exception e)
{
if (verbose && Application.isEditor)
{
Debug.LogError("Error in ApplyDataRendererInfo:" + e.GetType().ToString());
}
}
}
public void SaveLightMap()
{
mLightMapInfo = new LightMapInfo();
mLightMapInfo.mLightMapMode = LightmapSettings.lightmapsMode;
mLightMapInfo.mLightDataCount = LightmapSettings.lightmaps.Length;
//缓存lightmap的信息
for (int i = 0; i < LightmapSettings.lightmaps.Length; i++)
{
LightmapData data = LightmapSettings.lightmaps[i];
if (data.lightmapColor != null)
{
mLightMapInfo.mLightMapColorList.Add(data.lightmapColor);
}
if (data.lightmapDir != null)
{
mLightMapInfo.mLightMapDirList.Add(data.lightmapDir);
}
if (data.shadowMask != null)
{
mLightMapInfo.mLightMapShadowList.Add(data.shadowMask);
}
}
//缓存renderer的信息
var renderers = GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer r in renderers)
{
if (r.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.mRenderer = r;
info.mLightMapOffsetScale = r.lightmapScaleOffset;
info.mLightMapIndex = r.lightmapIndex;
mLightMapInfo.mRendererList.Add(info);
}
}
//设置地形
mLightMapInfo.mTerrain = GetComponentInChildren <Terrain>();
if (mLightMapInfo.mTerrain != null)
{
mLightMapInfo.mTerrainRendererInfo = new RendererInfo();
mLightMapInfo.mTerrainRendererInfo.mLightMapOffsetScale = mLightMapInfo.mTerrain.lightmapScaleOffset;
mLightMapInfo.mTerrainRendererInfo.mLightMapIndex = mLightMapInfo.mTerrain.lightmapIndex;
}
}
/// <summary>
/// Creates a new app with the specified window settings.
/// </summary>
/// <remarks>
/// If you have your own constructor, make sure to call this
/// one because it initializes the window and the event queue.
/// </remarks>
/// <param name="driver">Specifies a renderer to be used. If null, first hardware-accelerated renderer is used.</param>
/// <param name="useSurfaceApi">If true, initializes <see cref="Surface" /> instead of <see cref="Graphics" /></param>
public App2D(WindowSettings settings = null, RendererInfo driver = null,
bool useSurfaceApi = false) : base(settings)
{
_useSurfaceApi = useSurfaceApi;
IsHardwareAccelerated = driver?.IsHardwareAccelerated ?? true;
if (!useSurfaceApi)
{
Graphics = new Graphics(Window, driver);
}
else
{
Resized += (s, e) => UpdateSurface();
UpdateSurface();
}
}
/// <summary>
/// GoWrapper will cache all renderers of your gameobject on constructor.
/// If your gameobject change laterly, call this function to update the cache.
/// GoWrapper会在构造函数里查询你的gameobject所有的Renderer并保存。如果你的gameobject
/// 后续发生了改变，调用这个函数通知GoWrapper重新查询和保存。
/// </summary>
public void CacheRenderers()
{
if (_canvas != null)
{
return;
}
RecoverMaterials();
_renderers.Clear();
Renderer[] items = _wrapTarget.GetComponentsInChildren <Renderer>(true);
int cnt = items.Length;
_renderers.Capacity = cnt;
for (int i = 0; i < cnt; i++)
{
Renderer r = items[i];
Material[] mats = r.sharedMaterials;
RendererInfo ri = new RendererInfo()
{
renderer = r,
materials = mats,
sortingOrder = r.sortingOrder
};
_renderers.Add(ri);
if (!_cloneMaterial && mats != null &&
((r is SkinnedMeshRenderer) || (r is MeshRenderer)))
{
int mcnt = mats.Length;
for (int j = 0; j < mcnt; j++)
{
Material mat = mats[j];
if (mat != null && mat.renderQueue != 3000) //Set the object rendering in Transparent Queue as UI objects
{
mat.renderQueue = 3000;
}
}
}
}
_renderers.Sort((RendererInfo c1, RendererInfo c2) =>
{
return(c1.sortingOrder - c2.sortingOrder);
});
_shouldCloneMaterial = _cloneMaterial;
}
static void GenerateLightmapInfo(GameObject root, List <RendererInfo> newRendererInfos, List <Texture2D> newLightmapsLight, List <Texture2D> newLightmapsDir, LightmapsMode newLightmapsMode)
{
//BuglyAgent.PrintLog(LogSeverity.LogDebug, "GenerateLightmapInfo");
var renderers = FindObjectsOfType(typeof(MeshRenderer));
if (GLog.IsLogInfoEnabled)
{
GLog.LogInfo("stored info for " + renderers.Length + " meshrenderers");
}
foreach (MeshRenderer renderer in renderers)
{
if (renderer.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.renderer = renderer;
info.lightmapOffsetScale = renderer.lightmapScaleOffset;
if (renderer.lightmapIndex >= LightmapSettings.lightmaps.Length)
{
if (GLog.IsLogErrorEnabled)
{
GLog.LogError("Render Errror");
}
continue;
}
Texture2D lightmaplight = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapColor;
info.lightmapIndex = newLightmapsLight.IndexOf(lightmaplight);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = newLightmapsLight.Count;
newLightmapsLight.Add(lightmaplight);
}
if (newLightmapsMode != LightmapsMode.NonDirectional)
{
Texture2D lightmapdir = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapDir;
info.lightmapIndex = newLightmapsDir.IndexOf(lightmapdir);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = newLightmapsDir.Count;
newLightmapsDir.Add(lightmapdir);
}
}
newRendererInfos.Add(info);
}
}
}
private void SaveLightmap()
{
fogInfo = new FogInfo();
fogInfo.fog = RenderSettings.fog;
fogInfo.fogMode = RenderSettings.fogMode;
fogInfo.fogColor = RenderSettings.fogColor;
fogInfo.fogStartDistance = RenderSettings.fogStartDistance;
fogInfo.fogEndDistance = RenderSettings.fogEndDistance;
lightmapNear = new List <Texture2D>();
lightmapFar = new List <Texture2D>();
for (int i = 0; i < LightmapSettings.lightmaps.Length; i++)
{
LightmapData data = LightmapSettings.lightmaps[i];
if (data.lightmapDir != null)
{
lightmapNear.Add(data.lightmapDir);
}
if (data.lightmapColor != null)
{
lightmapFar.Add(data.lightmapColor);
}
}
m_RendererInfo = new List <RendererInfo>();
var renderers = GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer r in renderers)
{
if (r.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.renderer = r;
info.lightmapOffsetScale = r.lightmapScaleOffset;
info.lightmapIndex = r.lightmapIndex;
m_RendererInfo.Add(info);
}
}
terrain = GetComponentInChildren <Terrain>();
if (terrain != null)
{
terrainRendererInfo = new RendererInfo();
terrainRendererInfo.lightmapOffsetScale = terrain.lightmapScaleOffset;
terrainRendererInfo.lightmapIndex = terrain.lightmapIndex;
}
lightmapsMode = LightmapSettings.lightmapsMode;
}
static void GenerateLightmapInfo(GameObject root, List <RendererInfo> newRendererInfos,
List <Texture2D> newLightmapsLight, List <Texture2D> newLightmapsDir, List <Texture2D> newShadowmasks,
LightmapsMode newLightmapsMode)
{
var renderers = FindObjectsOfType(typeof(MeshRenderer));
Debug.Log("stored info for " + renderers.Length + " meshrenderers");
foreach (MeshRenderer renderer in renderers)
{
// TEMP CODE!!!!!!!!!!!! 测试场景中有很多物体用的shader无法烘焙出lightmap,index=65536.... by mage
//if (renderer.lightmapIndex != -1)
if (renderer.lightmapIndex == 0)
{
RendererInfo info = new RendererInfo();
info.renderer = renderer;
info.lightmapOffsetScale = renderer.lightmapScaleOffset;
Texture2D lightmaplight = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapColor;
info.lightmapIndex = newLightmapsLight.IndexOf(lightmaplight);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = newLightmapsLight.Count;
newLightmapsLight.Add(lightmaplight);
}
Texture2D shadowmask = LightmapSettings.lightmaps[renderer.lightmapIndex].shadowMask;
info.lightmapIndex = newShadowmasks.IndexOf(shadowmask);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = newShadowmasks.Count;
newShadowmasks.Add(shadowmask);
}
if (newLightmapsMode != LightmapsMode.NonDirectional)
{
Texture2D lightmapdir = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapDir;
info.lightmapIndex = newLightmapsDir.IndexOf(lightmapdir);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = newLightmapsDir.Count;
newLightmapsDir.Add(lightmapdir);
}
}
newRendererInfos.Add(info);
}
}
}
public void LoadLightmap()
{
if (AllRendererInfo == null || AllRendererInfo.Count == 0)
{
return;
}
for (int i = 0; i < AllRendererInfo.Count; i++)
{
RendererInfo rendererInfo = AllRendererInfo[i];
if (rendererInfo.renderer == null)
{
continue;
}
rendererInfo.renderer.lightmapIndex = rendererInfo.lightmapIndex;
rendererInfo.renderer.lightmapScaleOffset = rendererInfo.lightmapOffsetScale;
}
}
public void InitializeItem()
{
gameObject.layer = 11;
GetComponentsInChildren <Transform>().ToList().ForEach(x => x.gameObject.layer = 11);
if (gameObject == null)
{
return;
}
var renderers = gameObject.GetComponentsInChildren <Renderer>();
rendererInfos = renderers.Select(rendererComponent =>
{
var rendererInfo = new RendererInfo
{
renderer = rendererComponent,
materials = rendererComponent.sharedMaterials.Select(material =>
{
var matInfo = new MaterialInfo
{
isColor1 = material.HasProperty("_Color"),
isPattern1 = material.HasProperty("_patternuv1"),
isEmission = material.HasProperty("_Emission"),
isAlpha = material.shader.name.Contains("Alpha"), // TODO: make this as utility and better detection of transparent shader.
isGlass = false, // Glass?
isColor2 = material.HasProperty("_Color2"),
isPattern2 = material.HasProperty("_patternuv2"),
isColor3 = material.HasProperty("_Color3"),
isPattern3 = material.HasProperty("_patternuv3")
};
return(matInfo);
}).ToArray()
};
return(rendererInfo);
}).ToArray();
info = new Info[3];
for (var i = 0; i < 3; i++)
{
info[i] = new Info {
defColor = Color.white
}
}
;
}
static void GenerateLightmapInfo(GameObject root, List <RendererInfo> rendererInfos, List <Texture2D> lightmaps, List <Texture2D> lightmapsDir, List <Texture2D> shadowMasks, List <LightInfo> lightsInfo)
{
var renderers = root.GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer renderer in renderers)
{
if (renderer.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.renderer = renderer;
if (renderer.lightmapScaleOffset != Vector4.zero)
{
info.lightmapOffsetScale = renderer.lightmapScaleOffset;
Texture2D lightmap = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapColor;
Texture2D lightmapDir = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapDir;
Texture2D shadowMask = LightmapSettings.lightmaps[renderer.lightmapIndex].shadowMask;
info.lightmapIndex = lightmaps.IndexOf(lightmap);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = lightmaps.Count;
lightmaps.Add(lightmap);
lightmapsDir.Add(lightmapDir);
shadowMasks.Add(shadowMask);
}
rendererInfos.Add(info);
}
}
}
var lights = root.GetComponentsInChildren <Light>(true);
foreach (Light l in lights)
{
LightInfo lightInfo = new LightInfo();
lightInfo.light = l;
lightInfo.lightmapBaketype = (int)l.lightmapBakeType;
lightInfo.mixedLightingMode = (int)UnityEditor.LightmapEditorSettings.mixedBakeMode;
lightsInfo.Add(lightInfo);
}
}
// RendererInfo
internal static Dictionary <string, object> ToDictionary(this RendererInfo rendererInfo)
{
Dictionary <string, object> dictionary = new Dictionary <string, object>();
if (!string.IsNullOrEmpty(rendererInfo.Label))
{
dictionary.Add("label", rendererInfo.Label);
}
if (!string.IsNullOrEmpty(rendererInfo.Description))
{
dictionary.Add("description", rendererInfo.Description);
}
if (rendererInfo.Symbol is IJsonSerializable)
{
dictionary.Add("symbol", ((IJsonSerializable)rendererInfo.Symbol).ToJson());
}
return(dictionary);
}
public void RecordLightMap()
{
lightmapDatas.Clear();
for (int i = 0; i < LightmapSettings.lightmaps.Length; i++)
{
var data = LightmapSettings.lightmaps[i];
lightmapDatas.Add(new LightmapInfo()
{
lightmapColor = data.lightmapColor, lightmapDir = data.lightmapDir, shadowMask = data.shadowMask
});
}
m_RendererInfoList.Clear();
Renderer[] renderers = GetComponentsInChildren <Renderer>();
foreach (Renderer r in renderers)
{
if (r.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.renderer = r;
info.lightmapIndex = r.lightmapIndex;
info.lightmapScaleOffset = r.lightmapScaleOffset;
m_RendererInfoList.Add(info);
}
}
/* m_ReflectInfoList.Clear();
* ReflectionProbe[] reflects = GetComponentsInChildren<ReflectionProbe>();
* foreach (ReflectionProbe rl in reflects)
* {
* if (rl.bakedTexture||rl.customBakedTexture||rl.texture)
* {
* ReflectProbeInfo info = new ReflectProbeInfo();
* info.bakedTexture = rl.bakedTexture;
* info.customBakedTexture = rl.customBakedTexture;
* m_ReflectInfoList.Add(info);
* }
* }*/
#if UNITY_EDITOR
UnityEditor.PrefabUtility.RecordPrefabInstancePropertyModifications(this);
#endif
}
static void ApplyRendererInfo (RendererInfo[] infos, int lightmapOffsetIndex)
{
for (int i=0;i<infos.Length;i++)
{
var info = infos[i];
//start
if(info.renderer != null)
{
#if UNITY_EDITOR
if (UnityEditor.GameObjectUtility.AreStaticEditorFlagsSet(info.renderer.gameObject, UnityEditor.StaticEditorFlags.BatchingStatic))
{
Debug.LogWarning("The renderer " + info.renderer.name + " is marked Batching Static. The static batch is created when building the player. " +
"Setting the lightmap scale and offset will not affect lightmapping UVs as they have the scale and offset already burnt in.", info.renderer);
}
#endif
info.renderer.lightmapIndex = info.lightmapIndex + lightmapOffsetIndex;
info.renderer.lightmapScaleOffset = info.lightmapOffsetScale;
}
else
{
if(info.terrain != null)
{
info.terrain.lightmapIndex = info.lightmapIndex + lightmapOffsetIndex;
info.terrain.lightmapScaleOffset = info.lightmapOffsetScale;
}
}
/*
#if UNITY_EDITOR
if (UnityEditor.GameObjectUtility.AreStaticEditorFlagsSet(info.renderer.gameObject, UnityEditor.StaticEditorFlags.BatchingStatic))
{
Debug.LogWarning("The renderer " + info.renderer.name + " is marked Batching Static. The static batch is created when building the player. " +
"Setting the lightmap scale and offset will not affect lightmapping UVs as they have the scale and offset already burnt in.", info.renderer);
}
#endif
info.renderer.lightmapIndex = info.lightmapIndex + lightmapOffsetIndex;
info.renderer.lightmapScaleOffset = info.lightmapOffsetScale;
*/
}
}
override public void Update(UpdateContext context)
{
if (onUpdate != null)
{
onUpdate(context);
}
if (_shouldCloneMaterial)
{
CloneMaterials();
}
if (_supportMask)
{
int cnt = _renderers.Count;
for (int i = 0; i < cnt; i++)
{
RendererInfo ri = _renderers[i];
Material[] mats = ri.materials;
if (mats != null)
{
int cnt2 = mats.Length;
for (int j = 0; j < cnt2; j++)
{
Material mat = mats[j];
if (mat != null)
{
context.ApplyClippingProperties(mat, false);
}
}
if (cnt2 > 0 && _cloneMaterial && ri.renderer != null &&
!Material.ReferenceEquals(ri.renderer.sharedMaterial, mats[0]))
{
ri.renderer.sharedMaterials = mats;
}
}
}
}
base.Update(context);
}
public void SaveLightmap()
{
if (m_RendererInfo == null)
{
m_RendererInfo = new List <RendererInfo>();
}
m_RendererInfo.Clear();
MeshRenderer[] renderers = GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer r in renderers)
{
if (r.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.renderer = r;
info.lightmapOffsetScale = r.lightmapScaleOffset;
info.lightmapIndex = r.lightmapIndex;
m_RendererInfo.Add(info);
}
}
}
virtual protected void ApplyClipping(UpdateContext context)
{
#if UNITY_2018_2_OR_NEWER
int cnt = _renderers.Count;
for (int i = 0; i < cnt; i++)
{
_renderers[i].renderer.GetMaterials(helperMaterials);
int cnt2 = helperMaterials.Count;
for (int j = 0; j < cnt2; j++)
{
Material mat = helperMaterials[j];
if (mat != null)
{
context.ApplyClippingProperties(mat, false);
}
}
helperMaterials.Clear();
}
#else
int cnt = _renderers.Count;
for (int i = 0; i < cnt; i++)
{
RendererInfo ri = _renderers[i];
Material[] mats = ri.materials;
if (mats != null)
{
int cnt2 = mats.Length;
for (int j = 0; j < cnt2; j++)
{
Material mat = mats[j];
if (mat != null)
{
context.ApplyClippingProperties(mat, false);
}
}
}
}
#endif
}
static void GenerateLightmapInfo (GameObject root, List<RendererInfo> rendererInfos, List<Texture2D> lightmaps)
{
var renderers = root.GetComponentsInChildren<MeshRenderer>();
foreach (MeshRenderer renderer in renderers)
{
if (renderer.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.renderer = renderer;
info.lightmapOffsetScale = renderer.lightmapScaleOffset;
Texture2D lightmap = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapFar;
info.lightmapIndex = lightmaps.IndexOf(lightmap);
if (info.lightmapIndex == -1)
{
info.lightmapIndex = lightmaps.Count;
lightmaps.Add(lightmap);
}
rendererInfos.Add(info);
}
}
//start
var terrains = root.GetComponentsInChildren<Terrain>();
foreach(Terrain terrain in terrains)
{
if(terrain.lightmapIndex != -1)
{
RendererInfo info = new RendererInfo();
info.terrain = terrain;
info.lightmapOffsetScale = terrain.lightmapScaleOffset;
Texture2D lightmap = LightmapSettings.lightmaps[terrain.lightmapIndex].lightmapFar;
info.lightmapIndex = lightmaps.IndexOf(lightmap);
if(info.lightmapIndex == -1)
{
info.lightmapIndex = lightmaps.Count;
lightmaps.Add(lightmap);
}
rendererInfos.Add(info);
}
}
}
private void InternalRegisterAttributeRenderer(string rendererTypeName, string attributeTypeName, string area)
{
string key = area;
if ((key == null) || (key.Trim().Length == 0))
{
key = GLOBAL_RENDERER_KEY;
}
IList rendererList = (IList)_area2renderers[key];
if (rendererList == null)
{
rendererList = new ArrayList();
_area2renderers[key] = rendererList;
}
RendererInfo rendererInfo = new RendererInfo(rendererTypeName, attributeTypeName);
rendererList.Add(rendererInfo);
if (!_attributeRenderers.Contains(rendererTypeName))
{
_attributeRenderers.Add(rendererTypeName);
}
}
