//public void GetMaterial()
//{
// var renderer = !m_display ? m_display.GetComponentInChildren<Renderer>() : null;
// var shaderInterface = ShaderInterface.GetInterface(defaultShader);
// if (renderer)
// {
// m_material = renderer.material;
// shaderInterface = ShaderInterface.GetInterface(m_material.shader);
// }
// else
// {
// m_material = new Material(Shader.Find(shaderInterface.shaderName));
// }
// SetShaderInterface(shaderInterface);
//}
public void SetShaderInterface(ShaderInterface shaderInterface)
{
if (!shaderInterface)
{
return;
}
m_shaderInterface = shaderInterface;
if (m_shaderInterface)
{
m_shaderInterface.shader = Shader.Find(m_shaderInterface.shaderName);
if (!m_material)
{
m_material = new Material(m_shaderInterface.shader);
if (!string.IsNullOrEmpty(materialName))
{
m_material.name = materialName;
}
}
}
// if (Debug.isDebugBuild) Debug.Log(this.name + " [Shader Interface] " + m_shaderInterface.name + " (" + shaderInterface.shaderName + ")");
//else if (Debug.isDebugBuild)
// Debug.Log(this.name + " [Shader Interface NULL]");
InitializeShaderInterface();
}
public static List <MaterialWidget> GenerateMaterialWidgets(AssetHandlerWidget displayWidget)
{
List <MaterialWidget> matWidgets = displayWidget.GetComponents <MaterialWidget>().ToList();
List <MaterialWidget> usedMatWidgets = new List <MaterialWidget>();
// TODO: Implement cleanup to destroy materials when disposing of this stuff.
if (displayWidget is SkyboxWidget)
{
if (((SkyboxWidget)displayWidget).stereo)
{
string shaderType = InternalShaders.Skybox;
if (((SkyboxWidget)displayWidget).type == SkyboxWidget.SkyboxType.Cubemap)
{
shaderType = InternalShaders.Skybox;
}
var leftMatWidget = matWidgets.FirstOrDefault(w => w.materialName == "left eye");
if (!leftMatWidget)
{
leftMatWidget = displayWidget.gameObject.AddComponent <MaterialWidget>();
leftMatWidget.materialName = "left eye";
}
leftMatWidget.defaultShader = shaderType;
leftMatWidget.Initialize(leftMatWidget.m_material);
leftMatWidget.UpdateMaterial();
var rightMatWidget = matWidgets.FirstOrDefault(w => w.materialName == "right eye");
if (!rightMatWidget)
{
rightMatWidget = displayWidget.gameObject.AddComponent <MaterialWidget>();
rightMatWidget.materialName = "right eye";
}
rightMatWidget.defaultShader = shaderType;
rightMatWidget.Initialize(rightMatWidget.m_material);
rightMatWidget.UpdateMaterial();
usedMatWidgets.Add(leftMatWidget);
usedMatWidgets.Add(rightMatWidget);
}
else
{
var materialWidget = matWidgets.FirstOrDefault();
if (!materialWidget)
{
materialWidget = displayWidget.gameObject.AddComponent <MaterialWidget>();
materialWidget.materialName = "skybox";
}
switch (((SkyboxWidget)displayWidget).type)
{
case SkyboxWidget.SkyboxType.SixSided:
materialWidget.defaultShader = InternalShaders.Skybox;
break;
case SkyboxWidget.SkyboxType.Cubemap:
materialWidget.defaultShader = InternalShaders.SkyboxCubemap;
break;
case SkyboxWidget.SkyboxType.Procedural:
materialWidget.defaultShader = InternalShaders.SkyboxProcedural;
break;
default:
break;
}
materialWidget.Initialize(materialWidget.m_material);
materialWidget.UpdateMaterial();
usedMatWidgets.Add(materialWidget);
}
}
else
{
var renderers = new List <Renderer>();
if (displayWidget is ModelWidget)
{
foreach (var go in displayWidget.GetComponentsInChildren <InstancedAssetWidget>())
{
renderers.AddRange(go.GetComponentsInChildren <Renderer>());
}
}
else
{
renderers.AddRange(displayWidget.GetComponentsInChildren <Renderer>());
}
for (int r = 0; r < renderers.Count; r++)
{
for (int i = 0; i < renderers[r].materials.Length; i++)
{
string materialName = renderers[r].materials[i].name + "[" + r + "]";
if (displayWidget is ParticleWidget)
{
//TODO: This needs better handling to facilitate possible future subemitter support
if (i == 0)
{
materialName = "Particle_Material";
}
else
{
materialName = "Trail_Material";
}
}
var matWidget = matWidgets.FirstOrDefault(m => !usedMatWidgets.Contains(m) && (m.materialName.Contains(materialName) || m.materialName.Contains(renderers[r].materials[i].name)));
if (matWidget)
{
if (displayWidget is ModelWidget)
{
renderers[r].materials[i].name = materialName;
}
usedMatWidgets.Add(matWidget);
matWidget.Initialize(renderers[r].materials[i]);
matWidget.UpdateMaterial();
}
else
{
matWidget = displayWidget.gameObject.AddComponent <MaterialWidget>();
if (displayWidget is ParticleWidget)
{
//TODO: This needs better handling to facilitate possible future subemitter support
if (i == 0)
{
renderers[r].materials[i].name = "Particle_Material";
}
else
{
renderers[r].materials[i].name = "Trail_Material";
}
renderers[r].materials[i].shader = Shader.Find(ShaderInterface.GetInterface(InternalShaders.Particles).shaderName);
}
else
{
renderers[r].materials[i].name = materialName;
}
matWidget.Initialize(renderers[r].materials[i]);
matWidget.UpdateWidgetState();
usedMatWidgets.Add(matWidget);
}
}
}
}
matWidgets.ForEach(m => { if (!usedMatWidgets.Contains(m))
{
GameObject.Destroy(m);
}
});
return(usedMatWidgets);
}
public void UpdateWidgetState()
{
//if (Debug.isDebugBuild) Debug.Log(this.name + " [Update Widget State] " + (m_material ? m_material.name : " NO MATERIAL") + " - " + (m_material.shader ? m_material.shader.name : " NO SHADER"));
if (!m_material)
{
var renderer = m_display.GetComponentInChildren <Renderer>();
if (renderer)
{
m_material = renderer.material;
}
else
{
return;
}
}
else
{
foreach (string kw in m_material.shaderKeywords)
{
Debug.Log(kw);
}
}
var shaderInterface = ShaderInterface.GetInterface(m_material.shader);
if (shaderInterface)
{
SetShaderInterface(shaderInterface);
}
else
{
SetShaderInterface(ShaderInterface.GetInterface(defaultShader));
}
UpdateWidgetKeywords();
floats.ForEach(p => { if (m_material.HasProperty(p.name))
{
p.value = m_material.GetFloat(p.name);
}
}); //else if (Debug.isDebugBuild) Debug.LogWarning(m_material.name + " [No Float Property] " + p.name); });
ranges.ForEach(p => { if (m_material.HasProperty(p.name))
{
p.value = m_material.GetFloat(p.name);
}
}); //else if (Debug.isDebugBuild) Debug.LogWarning(m_material.name + " [No Range Property] " + p.name); });
colors.ForEach(p => { if (m_material.HasProperty(p.name))
{
p.value = m_material.GetColor(p.name);
}
}); //else if (Debug.isDebugBuild) Debug.LogWarning(m_material.name + " [No Color Property] " + p.name); });
vectors.ForEach(p => { if (m_material.HasProperty(p.name))
{
p.value = m_material.GetVector(p.name);
}
}); //else if (Debug.isDebugBuild) Debug.LogWarning(m_material.name + " [No Vector Property] " + p.name); });
textures.ForEach(p =>
{
if (m_material.HasProperty(p.name))
{
p.value = m_material.GetTexture(p.name);
p.tiling = m_material.GetTextureScale(p.name);
p.offset = m_material.GetTextureOffset(p.name);
}
});//else if (Debug.isDebugBuild) Debug.LogWarning(m_material.name + " [No Texture Property] " + p.name); });
}
public void UpdateMaterial()
{
//TODO: Need to implement setup of Shader Assets.
ShaderInterface shaderInterface = null;
if (!string.IsNullOrEmpty(shaderName))
{
shaderInterface = ShaderInterface.GetInterface(Shader.Find(shaderName));
}
if (!shaderInterface)
{
shaderInterface = ShaderInterface.GetInterface(defaultShader);
}
SetShaderInterface(shaderInterface);
if (!m_shaderInterface)
{
//if (Debug.isDebugBuild) Debug.LogError(this.name + " [Shader Interface Null]");
return;
}
//else if (Debug.isDebugBuild)
//{
// Debug.Log(this.name + " [Shader Interface Ready] " + defaultShader.ToString() + " - " + (m_shaderInterface.shader ? m_shaderInterface.shader.name : " NO SHADER"));
//}
m_material.shader = m_shaderInterface.shader;
//if (Debug.isDebugBuild) Debug.Log(this.name + " [Update Widget State] " + (m_material ? m_material.name : " NO MATERIAL") + " - " + (m_material.shader ? m_material.shader.name : " NO SHADER"));
floats.ForEach(p => { if (m_material.HasProperty(p.name))
{
m_material.SetFloat(p.name, p.value);
}
}); //else if (Debug.isDebugBuild) Debug.LogWarning(m_material.name + " [No Float Property] " + p.name); });
ranges.ForEach(p => { if (m_material.HasProperty(p.name))
{
m_material.SetFloat(p.name, p.value);
}
}); //else if (Debug.isDebugBuild) Debug.LogWarning(m_material.name + " [No Range Property] " + p.name); });
colors.ForEach(p => { if (m_material.HasProperty(p.name))
{
m_material.SetColor(p.name, p.value);
}
}); //else if (Debug.isDebugBuild) Debug.LogWarning(m_material.name + " [No Color Property] " + p.name); });
vectors.ForEach(p => { if (m_material.HasProperty(p.name))
{
m_material.SetVector(p.name, p.value);
}
}); //else if (Debug.isDebugBuild) Debug.LogWarning(m_material.name + " [No Vector Property] " + p.name); });
foreach (var texProperty in textures)
{
if (m_material.HasProperty(texProperty.name))
{
if (!string.IsNullOrEmpty(texProperty.assetId))
{
StartCoroutine(texProperty.FetchAsset(this, m_material));
}
else if (!string.IsNullOrEmpty(texProperty.url))
{
StartCoroutine(texProperty.FetchTexture(m_material));
}
m_material.SetTextureScale(texProperty.name, texProperty.tiling);
m_material.SetTextureOffset(texProperty.name, texProperty.offset);
}
}
DynamicGI.UpdateEnvironment();
foreach (var renderer in m_display.GetComponentsInChildren <Renderer>())
{
DynamicGI.UpdateMaterials(renderer);
}
UpdateMaterialKeywords();
}
public void SetShader(ShaderInterface shaderInterface)
{
m_shaderInterface = shaderInterface;
m_material.shader = m_shaderInterface.shader;
shaderName = m_shaderInterface.shaderName;
}
