public void RemoveLight(SceneLight light)
{
lights.Remove(light);
light.gameObject.SetActive(false);
Destroy(light.gameObject);
LightRemoved?.Invoke(light);
}
/// <summary>
/// Update lights.
/// </summary>
/// <param name="light"></param>
public override void UpdateLighting(SceneLight light)
{
if (_material != null)
{
_material.Light = light;
}
}
/// <summary>
/// Update the current effect. This method will change.
/// </summary>
/// <param name="effect"></param>
/// <param name="material"></param>
private void UpdateEffect(BasicEffect effect, BasicMaterial material)
{
effect.Alpha = material.AlphaColor;
effect.AmbientLightColor = material.AmbientColor * material.AmbientIntensity;
effect.DiffuseColor = material.DiffuseColor * material.DiffuseIntensity;
effect.EmissiveColor = material.EmissiveColor * material.EmissiveIntensity;
effect.FogColor = material.FogColor;
effect.FogEnabled = material.EnableFog;
effect.FogStart = material.FogStart;
effect.FogEnd = material.FogEnd;
effect.LightingEnabled = true;
if (material.EnableDefaultLighting)
{
effect.EnableDefaultLighting();
}
effect.PreferPerPixelLighting = material.EnabledPerPixelLighting;
effect.SpecularColor = material.SpecularColor * material.SpecularIntensity;
effect.VertexColorEnabled = material.EnableVertexColor;
SceneLight light = (SceneLight)material.Light;
if (light != null)
{
StockMaterial.UpdateLighting(effect, light);
effect.AmbientLightColor *= light.AmbientColor * light.AmbientIntensity;
}
}
/// <summary>
/// Update lights.
/// </summary>
/// <param name="light">Light to use.</param>
public override void UpdateLighting(SceneLight light)
{
foreach (YnEntity3D entity3D in _members)
{
entity3D.UpdateLighting(light);
}
}
private void LightRemoved(SceneLight layer)
{
LightItem item = lights[layer];
lights.Remove(layer);
item.gameObject.SetActive(false);
Destroy(item.gameObject);
}
private void LightAdded(SceneLight light)
{
GameObject go = Instantiate(lightItemPrefab, contentHolder.transform);
go.name = light.name;
LightItem item = go.GetComponent <LightItem>();
item.Light = light;
item.SetToggleIcon();
lights.Add(light, item);
}
/// <summary>
/// Update lights.
/// </summary>
/// <param name="light"></param>
public override void UpdateLighting(SceneLight light)
{
if (_material != null)
{
_material.Light = light;
}
else if (_materials != null)
{
foreach (BaseMaterial material in _materials)
{
material.Light = light;
}
}
}
public SceneLight CreateLight()
{
SceneLight light = Instantiate(LightPrefab, LightHolder.transform).GetComponent <SceneLight>();
light.name = $"Light {lightCount++}";
Vector3 lookDirection = Camera.main.transform.forward;
light.transform.position = Camera.main.transform.position + lookDirection.normalized * distance;
light.transform.rotation = Quaternion.LookRotation(-lookDirection, Vector3.up);
light.SetColor(light.light.color);
lights.Add(light);
LightAdded?.Invoke(light);
return(light);
}
public static void UpdateLighting(IEffectLights effect, SceneLight light)
{
effect.DirectionalLight0.Enabled = light.DirectionalLights[0].Enabled;
effect.DirectionalLight0.Direction = light.DirectionalLights[0].Direction;
effect.DirectionalLight0.DiffuseColor = light.DirectionalLights[0].DiffuseColor * light.DirectionalLights[0].DiffuseIntensity;
effect.DirectionalLight0.SpecularColor = light.DirectionalLights[0].SpecularColor * light.DirectionalLights[0].SpecularIntensity;
effect.DirectionalLight1.Enabled = light.DirectionalLights[1].Enabled;
effect.DirectionalLight1.Direction = light.DirectionalLights[1].Direction;
effect.DirectionalLight1.DiffuseColor = light.DirectionalLights[1].DiffuseColor * light.DirectionalLights[1].DiffuseIntensity;
effect.DirectionalLight1.SpecularColor = light.DirectionalLights[1].SpecularColor * light.DirectionalLights[1].SpecularIntensity;
effect.DirectionalLight2.Enabled = light.DirectionalLights[2].Enabled;
effect.DirectionalLight2.Direction = light.DirectionalLights[2].Direction;
effect.DirectionalLight2.DiffuseColor = light.DirectionalLights[2].DiffuseColor * light.DirectionalLights[2].DiffuseIntensity;
effect.DirectionalLight2.SpecularColor = light.DirectionalLights[2].SpecularColor * light.DirectionalLights[2].SpecularIntensity;
}
private void Awake()
{
if (_instance != null && _instance != this)
{
Destroy(this.gameObject);
return;
}
_instance = this;
lights = new List <SceneLight>();
SceneLight light = Instantiate(LightPrefab, LightHolder.transform).GetComponent <SceneLight>();
light.name = $"Main light";
light.transform.position = new Vector3(0, 3, 0);
light.transform.rotation = Quaternion.Euler(50, -30, 0);
light.light.intensity = 0.8f;
light.SetColor(light.light.color);
lights.Add(light);
}
/// <summary>
/// Update lights.
/// </summary>
/// <param name="light">Light to use.</param>
public virtual void UpdateLighting(SceneLight light)
{
}
/// <summary>
/// Update lights.
/// </summary>
/// <param name="light"></param>
public override void UpdateLighting(SceneLight light)
{
if (_material != null)
{
_material.Light = light;
}
else if (_materials != null)
{
foreach (BaseMaterial material in _materials)
material.Light = light;
}
}
private void LoadDefaultUI()
{
PaletteMap.Show();
SceneLight.UpadteGameGraphSetting();
}
/// <summary>
/// Update lights.
/// </summary>
/// <param name="light"></param>
public override void UpdateLighting(SceneLight light)
{
if (_material != null)
_material.Light = light;
}
public static void UpdateLighting(IEffectLights effect, SceneLight light)
{
effect.DirectionalLight0.Enabled = light.DirectionalLights[0].Enabled;
effect.DirectionalLight0.Direction = light.DirectionalLights[0].Direction;
effect.DirectionalLight0.DiffuseColor = light.DirectionalLights[0].DiffuseColor * light.DirectionalLights[0].DiffuseIntensity;
effect.DirectionalLight0.SpecularColor = light.DirectionalLights[0].SpecularColor * light.DirectionalLights[0].SpecularIntensity;
effect.DirectionalLight1.Enabled = light.DirectionalLights[1].Enabled;
effect.DirectionalLight1.Direction = light.DirectionalLights[1].Direction;
effect.DirectionalLight1.DiffuseColor = light.DirectionalLights[1].DiffuseColor * light.DirectionalLights[1].DiffuseIntensity;
effect.DirectionalLight1.SpecularColor = light.DirectionalLights[1].SpecularColor * light.DirectionalLights[1].SpecularIntensity;
effect.DirectionalLight2.Enabled = light.DirectionalLights[2].Enabled;
effect.DirectionalLight2.Direction = light.DirectionalLights[2].Direction;
effect.DirectionalLight2.DiffuseColor = light.DirectionalLights[2].DiffuseColor * light.DirectionalLights[2].DiffuseIntensity;
effect.DirectionalLight2.SpecularColor = light.DirectionalLights[2].SpecularColor * light.DirectionalLights[2].SpecularIntensity;
}
/// <summary>
/// Update lights.
/// </summary>
/// <param name="light">Light to use.</param>
public virtual void UpdateLighting(SceneLight light)
{
}
public YnScene3D()
: base(null)
{
_sceneLight = new SceneLight();
_sceneLight.AmbientIntensity = 1f;
}
public YnScene3D()
: base(null)
{
_sceneLight = new SceneLight();
_sceneLight.AmbientIntensity = 1f;
}
public void AddLightChangeListener(ColorPicker picker, SceneLight light)
{
picker.onValueChanged.AddListener((c) => light.SetColor(c));
}
/// <summary>
/// Update lights.
/// </summary>
/// <param name="light">Light to use.</param>
public override void UpdateLighting(SceneLight light)
{
foreach (YnEntity3D entity3D in _members)
entity3D.UpdateLighting(light);
}
/// <summary>
/// Draw entities on screen.
/// </summary>
/// <param name="device"></param>
/// <param name="camera"></param>
/// <param name="light"></param>
public virtual void Draw(GameTime gameTime, GraphicsDevice device, BaseCamera camera, SceneLight light)
{
if (_safeMembers.Count > 0)
{
for (int i = 0, l = _safeMembers.Count; i < l; i++)
{
if (_safeMembers[i].Enabled)
{
if (light != null)
{
_safeMembers[i].UpdateLighting(light);
}
_safeMembers[i].Draw(gameTime, device, camera);
}
}
}
}
private void ToGenerateVariant(GameObject root, EVariantType variantType)
{
m_config = new SceneConfig();
//var root = GameObject.Find(m_rootName);
string folderName = UnityEngine.SceneManagement.SceneManager.GetActiveScene().name;
if (System.IO.Directory.Exists(m_packageFolder + folderName + "/" + variantType.ToString()))
{
DelectDir(m_packageFolder + folderName + "/" + variantType.ToString());
}
Directory.CreateDirectory(m_packageFolder + folderName + "/" + variantType.ToString());
MeshRenderer[] meshRenders = root.GetComponentsInChildren <MeshRenderer>();
List <MeshRenderer> renlist = new List <MeshRenderer>();
List <MeshFilter> filList = new List <MeshFilter>();
for (int i = 0; i < meshRenders.Length; i++)
{
var meshRender = meshRenders[i];
var meshFilter = meshRender.GetComponent <MeshFilter>();
if (meshFilter == null)
{
continue;
}
if (meshRender.sharedMaterials.Length <= 0 || meshRender.sharedMaterial == null)
{
continue;
}
bool has = false;
for (int j = 0; j < renlist.Count; j++)
{
if (filList[j].mesh == meshFilter.sharedMesh && renlist[j].sharedMaterials.Length == meshRender.sharedMaterials.Length && renlist[i].sharedMaterial == meshRender.sharedMaterial)
{
has = true;
break;
}
}
if (has)
{
continue;
}
var f = meshRender.GetComponent <MeshFilter>();
if (f == null)
{
continue;
}
renlist.Add(meshRender);
filList.Add(f);;
var obj = GameObject.Instantiate(meshRender.gameObject);
var ani = obj.GetComponent <Animator>();
if (ani != null && ani.runtimeAnimatorController == null)
{
UnityEngine.Object.DestroyImmediate(ani);
}
var a = obj.GetComponent <Animation>();
if (a != null && a.GetClipCount() <= 0)
{
UnityEngine.Object.DestroyImmediate(a);
}
var prefab = PrefabUtility.CreateEmptyPrefab(m_packageFolder + folderName + "/" + variantType.ToString() + "/" + meshRender.gameObject.name + ".prefab");
PrefabUtility.ReplacePrefab(obj, prefab);
UnityEngine.Object.DestroyImmediate(obj);
}
var cloneRoot = Object.Instantiate(root);
m_config.objs = new List <SceneObj>();
TraverseChildNode(cloneRoot.transform);
var rootPrefab = PrefabUtility.CreateEmptyPrefab(m_packageFolder + folderName + "/" + variantType.ToString() + "/root.prefab");
PrefabUtility.ReplacePrefab(cloneRoot, rootPrefab);
UnityEngine.Object.DestroyImmediate(cloneRoot);
if (RenderSettings.fog)
{
m_config.fog = new SceneFog();
m_config.fog.colorR = RenderSettings.fogColor.r;
m_config.fog.colorG = RenderSettings.fogColor.g;
m_config.fog.colorB = RenderSettings.fogColor.b;
m_config.fog.colorA = RenderSettings.fogColor.a;
m_config.fog.fogMode = (int)RenderSettings.fogMode;
m_config.fog.fogDensity = RenderSettings.fogDensity;
m_config.fog.fogStartDistance = RenderSettings.fogStartDistance;
m_config.fog.fogEndDistance = RenderSettings.fogEndDistance;
}
if (RenderSettings.skybox != null)
{
if (!RenderSettings.skybox.name.Contains("Default-"))
{
AssetDatabase.CopyAsset(UnityEditor.AssetDatabase.GetAssetPath(RenderSettings.skybox), m_packageFolder + folderName + "/" + variantType.ToString() + "/" + m_config.skybox + ".mat");
m_config.skybox = RenderSettings.skybox.name;
}
}
if (LightmapSettings.lightmaps != null)
{
m_config.lightmap = new SceneLightmap();
m_config.lightmap.mode = (int)LightmapSettings.lightmapsMode;
m_config.lightmap.datas = new List <SceneLightmapData>();
for (int i = 0; i < LightmapSettings.lightmaps.Length; i++)
{
Texture2D color = LightmapSettings.lightmaps[i].lightmapColor;
Texture2D dir = LightmapSettings.lightmaps[i].lightmapDir;
string colorName = color != null?color.name.Trim() : null;
if (!string.IsNullOrEmpty(colorName))
{
AssetDatabase.CopyAsset(UnityEditor.AssetDatabase.GetAssetPath(color), m_packageFolder + folderName + "/" + variantType.ToString() + "/" + colorName + ".exr");
}
string dirName = dir != null?dir.name.Trim() : null;
if (string.IsNullOrEmpty(dirName))
{
AssetDatabase.CopyAsset(UnityEditor.AssetDatabase.GetAssetPath(dir), m_packageFolder + folderName + "/" + variantType.ToString() + "/" + dirName + ".exr");
}
m_config.lightmap.datas.Add(new SceneLightmapData()
{
color = colorName,
dir = dirName
});
}
}
var lightObj = GameObject.Find(m_lightName);
if (lightObj != null)
{
m_config.lights = new List <SceneLight>();
var lights = lightObj.GetComponentsInChildren <UnityEngine.Light>();
for (int i = 0; i < lights.Length; i++)
{
var light = lights[i];
var lightConfig = new SceneLight();
lightConfig.colorR = light.color.r;
lightConfig.colorG = light.color.g;
lightConfig.colorB = light.color.b;
lightConfig.colorA = light.color.a;
lightConfig.eulerAngleX = light.transform.eulerAngles.x;
lightConfig.eulerAngleY = light.transform.eulerAngles.y;
lightConfig.eulerAngleZ = light.transform.eulerAngles.z;
lightConfig.positionX = light.transform.position.x;
lightConfig.positionY = light.transform.position.y;
lightConfig.positionZ = light.transform.position.z;
lightConfig.intensity = light.intensity;
lightConfig.type = (int)light.type;
lightConfig.range = light.range;
lightConfig.spotAngle = light.spotAngle;
lightConfig.width = light.areaSize.x;
lightConfig.height = light.areaSize.y;
m_config.lights.Add(lightConfig);
}
}
byte[] bytes = Serialize <SceneConfig>(m_config);
using (FileStream stream = new FileStream(m_packageFolder + folderName + "/" + variantType.ToString() + "/config.bytes", FileMode.Create, FileAccess.Write))
{
stream.Write(bytes, 0, bytes.Length);
}
AssetDatabase.Refresh();
ToBundle(m_packageFolder + folderName, variantType);
}
public static void Add(SceneLight newLight)
{
sceneLights.Add(newLight);
}
