| public GetVector ( int nameID ) : Vector4 | ||
| nameID | int | The name ID of the property retrieved by Shader.PropertyToID. |
| return | Vector4 | |
protected override void Init()
{
if (null == m_target)
{
return;
}
// end if
var renderer = m_target.GetComponent <Renderer>();
if (null != renderer)
{
m_Material = renderer.material;
}
// end if
if (null == m_Material)
{
return;
}
// end if
if (!string.IsNullOrEmpty(m_property))
{
m_beginVector = m_Material.GetVector(m_property);
}
else if (-1 != m_propertyID)
{
m_beginVector = m_Material.GetVector(m_propertyID);
} // end if
}
protected override void SetMaterialKeywords(UnityEngine.Material material)
{
bool applyTintOnTopOfTexture = material.GetFloat("_Waterfall2D_IsApplyTintColorOnTopOfTextureEnabled") == 1f;
SetKeywordState(material, "Waterfall2D_ApplyTintColorBeforeTexture", !applyTintOnTopOfTexture);
// Body Keywords
bool hasBodyTexture = material.GetTexture("_BodyTexture") != null;
bool isBodyTextureAlphaCutoffEnabled = material.GetInt("_Waterfall2D_IsBodyTextureAlphaCutoffEnabled") == 1;
bool isBodyTextureSheetEnabled = material.GetInt("_Waterfall2D_IsBodyTextureSheetEnabled") == 1;
bool isBodyTextureSheetWithLerpEnabled = material.GetInt("_Waterfall2D_IsBodyTextureSheetWithLerpEnabled") == 1;
Vector4 bodyTextureTilingModeParameters = material.GetVector("_BodyTextureTilingParameters");
bool isBodyTextureTilingModeSetToStretch = bodyTextureTilingModeParameters.x == 1f;
bool isBodyTextureStretchTilingModeKeepAspect = bodyTextureTilingModeParameters.y == 1f;
bool isBodyTextureStretchTilingModeAutoX = bodyTextureTilingModeParameters.z == 1f;
bool hasBodySecondTexture = material.GetTexture("_BodySecondTexture") != null;
bool isBodySecondTextureSheetEnabled = material.GetInt("_Waterfall2D_IsBodySecondTextureSheetEnabled") == 1;
bool isBodySecondTextureSheetWithLerpEnabled = material.GetInt("_Waterfall2D_IsBodySecondTextureSheetWithLerpEnabled") == 1;
Vector4 bodySecondTextureTilingModeParameters = material.GetVector("_BodySecondTextureTilingParameters");
bool isBodySecondTextureTilingModeSetToStretch = bodySecondTextureTilingModeParameters.x == 1f;
bool isBodySecondTextureStretchTilingModeKeepAspect = bodySecondTextureTilingModeParameters.y == 1f;
bool isBodySecondTextureStretchTilingModeAutoX = bodySecondTextureTilingModeParameters.z == 1f;
SetKeywordState(material, "Waterfall2D_BodyTexture", hasBodyTexture && !isBodyTextureSheetEnabled && !(isBodyTextureSheetEnabled && isBodyTextureSheetWithLerpEnabled));
SetKeywordState(material, "Waterfall2D_BodyTextureSheet", hasBodyTexture && isBodyTextureSheetEnabled & !isBodyTextureSheetWithLerpEnabled);
SetKeywordState(material, "Waterfall2D_BodyTextureSheetWithLerp", hasBodyTexture && isBodyTextureSheetEnabled & isBodyTextureSheetWithLerpEnabled);
SetKeywordState(material, "Waterfall2D_BodyTextureStretch", hasBodyTexture && isBodyTextureTilingModeSetToStretch && !isBodyTextureStretchTilingModeKeepAspect);
SetKeywordState(material, "Waterfall2D_BodyTextureStretchAutoX", hasBodyTexture && isBodyTextureTilingModeSetToStretch && isBodyTextureStretchTilingModeKeepAspect && isBodyTextureStretchTilingModeAutoX);
SetKeywordState(material, "Waterfall2D_BodyTextureStretchAutoY", hasBodyTexture && isBodyTextureTilingModeSetToStretch && isBodyTextureStretchTilingModeKeepAspect && !isBodyTextureStretchTilingModeAutoX);
SetKeywordState(material, "Waterfall2D_BodySecondTexture", hasBodySecondTexture && !isBodySecondTextureSheetEnabled && !(isBodySecondTextureSheetEnabled && isBodySecondTextureSheetWithLerpEnabled));
SetKeywordState(material, "Waterfall2D_BodySecondTextureSheet", hasBodySecondTexture && isBodySecondTextureSheetEnabled & !isBodySecondTextureSheetWithLerpEnabled);
SetKeywordState(material, "Waterfall2D_BodySecondTextureSheetWithLerp", hasBodySecondTexture && isBodySecondTextureSheetEnabled & isBodySecondTextureSheetWithLerpEnabled);
SetKeywordState(material, "Waterfall2D_BodySecondTextureStretch", hasBodySecondTexture && isBodySecondTextureTilingModeSetToStretch && !isBodySecondTextureStretchTilingModeKeepAspect);
SetKeywordState(material, "Waterfall2D_BodySecondTextureStretchAutoX", hasBodySecondTexture && isBodySecondTextureTilingModeSetToStretch && isBodySecondTextureStretchTilingModeKeepAspect && isBodySecondTextureStretchTilingModeAutoX);
SetKeywordState(material, "Waterfall2D_BodySecondTextureStretchAutoY", hasBodySecondTexture && isBodySecondTextureTilingModeSetToStretch && isBodySecondTextureStretchTilingModeKeepAspect && !isBodySecondTextureStretchTilingModeAutoX);
SetKeywordState(material, "Waterfall2D_BodyColorGradient", material.GetInt("_Waterfall2D_IsColorGradientEnabled") == 1);
SetKeywordState(material, "Waterfall2D_BodyTextureNoise", hasBodyTexture && (material.GetInt("_Waterfall2D_IsBodyNoiseEnabled") == 1));
SetKeywordState(material, "Waterfall2D_BodyTextureAlphaCutoff", (hasBodyTexture || hasBodySecondTexture) && isBodyTextureAlphaCutoffEnabled);
// Top-Bottom / Left-Right Edges
SetEdgesKeywords(material, "Top", "Bottom");
SetEdgesKeywords(material, "Left", "Right");
// Refraction
bool isRefractionEnabled = material.GetInt("_Waterfall2D_IsRefractionEnabled") == 1;
SetKeywordState(material, "Waterfall2D_Refraction", isRefractionEnabled);
// Emission
bool isEmissionEnabled = material.GetInt("_Waterfall2D_IsEmissionColorEnabled") == 1;
SetKeywordState(material, "Waterfall2D_ApplyEmissionColor", isEmissionEnabled);
}
static public int GetVector(IntPtr l)
{
try{
if (matchType(l, 2, typeof(System.String)))
{
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
System.String a1;
checkType(l, 2, out a1);
UnityEngine.Vector4 ret = self.GetVector(a1);
pushValue(l, ret);
return(1);
}
else if (matchType(l, 2, typeof(System.Int32)))
{
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
System.Int32 a1;
checkType(l, 2, out a1);
UnityEngine.Vector4 ret = self.GetVector(a1);
pushValue(l, ret);
return(1);
}
LuaDLL.luaL_error(l, "No matched override function to call");
return(0);
}
catch (Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return(0);
}
}
static public int GetVector(IntPtr l)
{
try {
int argc = LuaDLL.lua_gettop(l);
if (matchType(l, argc, 2, typeof(int)))
{
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
System.Int32 a1;
checkType(l, 2, out a1);
var ret = self.GetVector(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
else if (matchType(l, argc, 2, typeof(string)))
{
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
System.String a1;
checkType(l, 2, out a1);
var ret = self.GetVector(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
pushValue(l, false);
LuaDLL.lua_pushstring(l, "No matched override function to call");
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
public static SMaterial FromMaterial(Material mat)
{
if (mat == null)
return null;
Shader shader = mat.shader;
if (shader == null)
return null;
SMaterial result = new SMaterial();
result.instanceID = mat.GetInstanceID();
result.materialName = mat.name;
result.shaderName = shader.name;
ShaderProperties.Info info = ShaderPropertyHelper.GetShaderInfo(shader.name);
if (info != null){
ComposedByteStream rawData = new ComposedByteStream();
int iMax = info.propertyNames.Length;
for (int i = 0; i < iMax; i++)
{
string propName = info.propertyNames[i];
switch (info.propertyTypes[i])
{
case ShaderProperties.PropType.Color:
Color color = mat.GetColor(propName);
rawData.AddStream(new float[] { color.r, color.g, color.b, color.a });
break;
case ShaderProperties.PropType.Range:
case ShaderProperties.PropType.Float:
rawData.AddStream(new float[] { mat.GetFloat(propName) });
break;
case ShaderProperties.PropType.TexEnv:
Texture texture = mat.GetTexture(propName);
Vector2 offset = mat.GetTextureOffset(propName);
Vector2 scale = mat.GetTextureScale(propName);
rawData.AddStream(new int[] { texture != null ? texture.GetInstanceID() : -1 });
rawData.AddStream(texture != null ? texture.name : "" );
rawData.AddStream(new float[] { offset.x, offset.y });
rawData.AddStream(new float[] { scale.x, scale.y });
break;
case ShaderProperties.PropType.Vector:
Vector4 vector = mat.GetVector(propName);
rawData.AddStream(new float[] { vector.x, vector.y, vector.z, vector.w });
break;
}
}
result.rawData = rawData.Compose();
return result;
} else {
if (vBug.settings.general.debugMode)
Debug.LogError("No shader-info found @" + shader.name);
return null;
}
}
public List<StoredValue> GetValues(Material m)
{
var list = GetShaderProperties(m);
var output = new List<StoredValue>();
foreach(var p in list)
{
var o = new StoredValue { Property = p };
output.Add(o);
switch(p.type)
{
case MaterialProperty.PropertyType.color:
o.Value = m.GetColor(p.name);
break;
case MaterialProperty.PropertyType.real:
o.Value = m.GetFloat(p.name);
break;
case MaterialProperty.PropertyType.texture:
o.Value = m.GetTexture(p.name);
break;
case MaterialProperty.PropertyType.vector:
o.Value = m.GetVector(p.name);
break;
case MaterialProperty.PropertyType.textureOffset:
o.Value = m.GetTextureOffset(p.name);
break;
case MaterialProperty.PropertyType.textureScale:
o.Value = m.GetTextureScale(p.name);
break;
case MaterialProperty.PropertyType.matrix:
o.Value = m.GetMatrix(p.name);
break;
}
}
return output;
}
public void SetFromToCurrent()
{
if (_material = material)
{
from = _material.GetVector(propertyID);
}
}
public override void OnRecord()
{
if (_material = material)
{
_original = _material.GetVector(propertyID);
}
}
/// <summary>
/// Copy Shader properties from source to destination material.
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static void CopyMaterialProperties(Material source, Material destination)
{
MaterialProperty[] source_prop = MaterialEditor.GetMaterialProperties(new Material[] { source });
for (int i = 0; i < source_prop.Length; i++)
{
int property_ID = Shader.PropertyToID(source_prop[i].name);
if (destination.HasProperty(property_ID))
{
//Debug.Log(source_prop[i].name + " Type:" + ShaderUtil.GetPropertyType(source.shader, i));
switch (ShaderUtil.GetPropertyType(source.shader, i))
{
case ShaderUtil.ShaderPropertyType.Color:
destination.SetColor(property_ID, source.GetColor(property_ID));
break;
case ShaderUtil.ShaderPropertyType.Float:
destination.SetFloat(property_ID, source.GetFloat(property_ID));
break;
case ShaderUtil.ShaderPropertyType.Range:
destination.SetFloat(property_ID, source.GetFloat(property_ID));
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
destination.SetTexture(property_ID, source.GetTexture(property_ID));
break;
case ShaderUtil.ShaderPropertyType.Vector:
destination.SetVector(property_ID, source.GetVector(property_ID));
break;
}
}
}
}
static int GetVector(IntPtr L)
{
try
{
int count = LuaDLL.lua_gettop(L);
if (count == 2 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Material), typeof(int)))
{
UnityEngine.Material obj = (UnityEngine.Material)ToLua.ToObject(L, 1);
int arg0 = (int)LuaDLL.lua_tonumber(L, 2);
UnityEngine.Vector4 o = obj.GetVector(arg0);
ToLua.Push(L, o);
return(1);
}
else if (count == 2 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Material), typeof(string)))
{
UnityEngine.Material obj = (UnityEngine.Material)ToLua.ToObject(L, 1);
string arg0 = ToLua.ToString(L, 2);
UnityEngine.Vector4 o = obj.GetVector(arg0);
ToLua.Push(L, o);
return(1);
}
else
{
return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.Material.GetVector"));
}
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
static void SetMatrix(Material material)
{
var r = material.GetVector("_Euler");
var q = Quaternion.Euler(r.x, r.y, r.z);
var m = Matrix4x4.TRS(Vector3.zero, q, Vector3.one);
material.SetVector("_Rotation1", m.GetRow(0));
material.SetVector("_Rotation2", m.GetRow(1));
material.SetVector("_Rotation3", m.GetRow(2));
}
public override void OnTween(float factor)
{
if (_material = material)
{
_temp = _material.GetVector(propertyID);
if (mask.GetBit(0)) _temp.x = from.x + (to.x - from.x) * factor;
if (mask.GetBit(1)) _temp.y = from.y + (to.y - from.y) * factor;
if (mask.GetBit(2)) _temp.z = from.z + (to.z - from.z) * factor;
if (mask.GetBit(3)) _temp.w = from.w + (to.w - from.w) * factor;
_material.SetVector(propertyID, _temp);
}
}
public void WriteToJson(IResMgr resmgr, Material mat, MyJson.JsonNode_Object json)
{
json["shaderName"] = new MyJson.JsonNode_ValueString(this.shaderName);
if (jsonConfig.ContainsKey("params"))
{
foreach (var item in jsonConfig["params"].asDict())
{
//Debug.Log(item.Value);
string type = item.Value.asDict()["type"].AsString();
string flag = item.Value.asDict()["flags"].AsString();
string name = item.Value.asDict()["name"].AsString();
if (type == "Float" || type == "Range")
{
json[name] = new MyJson.JsonNode_ValueNumber(mat.GetFloat(name));
}
else if (type == "Vector")
{
json[name] = new MyJson.JsonNode_ValueString(StringHelper.ToString(mat.GetVector(name)));
}
else if (type == "Color")
{
json[name] = new MyJson.JsonNode_ValueString(StringHelper.ToString((Color32)mat.GetColor(name)));
}
else if (type == "Texture")
{
string texdim = item.Value.asDict()["texdim"].AsString();
var tex = mat.GetTexture(name);
if (tex != null)
{
if (texdim == "Tex2D")
{
string texname = resmgr.SaveTexture(tex as Texture2D);
json[name] = new MyJson.JsonNode_ValueString(texname);
}
else
{
throw new Exception("not support texdim:" + texdim);
}
}
}
else
{
throw new Exception("not support type:" + type);
}
}
}
}
/// <summary>
/// Gets the values given a material
/// </summary>
/// <param name="m">The material</param>
/// <returns>A StoredValue containing value and type information</returns>
public List<StoredValue> GetValues(Material m)
{
var list = GetShaderProperties(m);
var output = new List<StoredValue>();
foreach (var p in list) {
var o = new StoredValue {
property = p
};
output.Add(o);
switch (p.type) {
case MaterialProperty.PropertyType.Color:
o.value = new object[1];
o.value[0] = m.GetColor(p.name);
break;
case MaterialProperty.PropertyType.Float:
o.value = new object[1];
o.value[0] = m.GetFloat(p.name);
break;
case MaterialProperty.PropertyType.Range:
o.value = new object[1];
o.value[0] = m.GetFloat(p.name);
break;
case MaterialProperty.PropertyType.TexEnv:
o.value = new object[3];
o.value[0] = m.GetTexture(p.name);
o.value[1] = m.GetTextureOffset(p.name);
o.value[2] = m.GetTextureScale(p.name);
break;
case MaterialProperty.PropertyType.Vector:
o.value = new object[1];
o.value[0] = m.GetVector(p.name);
break;
default:
Debug.LogError("Unsupported type: " + p.type.ToString());
break;
}
}
return output;
}
private BabylonMaterial DumpShaderMaterial(Material material)
{
if (materialsDictionary.ContainsKey(material.name))
{
return materialsDictionary[material.name];
}
var babylonShaderMaterial = new BabylonShaderMaterial
{
name = material.name,
id = Guid.NewGuid().ToString(),
};
ExporterWindow.ReportProgress(1, "Exporting glsl material: " + material.name);
List<string> tnames = material.GetTextureNames();
foreach (string tname in tnames)
{
BabylonTexture tdata = DumpTextureFromMaterial(material, tname);
if (tdata != null)
{
babylonShaderMaterial.textures.Add(tname, tdata);
}
}
List<string> fnames = material.GetFloatNames();
foreach (string fname in fnames)
{
float fdata = material.GetFloat(fname);
babylonShaderMaterial.floats.Add(fname, fdata);
}
List<string> rnames = material.GetRangeNames();
foreach (string rname in rnames)
{
float rdata = material.GetFloat(rname);
babylonShaderMaterial.floats.Add(rname, rdata);
}
List<string> cnames = material.GetColorNames();
foreach (string cname in cnames)
{
Color cdata = material.GetColor(cname);
babylonShaderMaterial.vectors4.Add(cname, cdata.ToFloat());
}
List<string> vnames = material.GetVectorNames();
foreach (string vname in vnames)
{
Vector4 vdata = material.GetVector(vname);
babylonShaderMaterial.vectors4.Add(vname, vdata.ToFloat());
}
Shader shader = material.shader;
string filename = AssetDatabase.GetAssetPath(shader);
string program = Tools.LoadTextAsset(filename);
string basename = shader.name.Replace("BabylonJS/", "").Replace("/", "_").Replace(" ", "");
string outpath = (!String.IsNullOrEmpty(exportationOptions.DefaultShaderFolder)) ? exportationOptions.DefaultShaderFolder : OutputPath;
var shaderpath = new Dictionary<string, string>();
List<string> attributeList = new List<string>();
List<string> uniformList = new List<string>();
List<string> samplerList = new List<string>();
List<string> defineList = new List<string>();
string babylonOptions = GetShaderProgramSection(basename, program, BabylonProgramSection.Babylon);
string[] babylonLines = babylonOptions.Split('\n');
foreach (string babylonLine in babylonLines)
{
if (babylonLine.IndexOf("attributes", StringComparison.OrdinalIgnoreCase) >= 0)
{
string[] attributes = babylonLine.Split(':');
if (attributes != null && attributes.Length > 1)
{
string abuffer = attributes[1].Replace("[", "").Replace("]", "");
if (!String.IsNullOrEmpty(abuffer))
{
abuffer = abuffer.Trim();
string[] adata = abuffer.Split(',');
if (adata != null && adata.Length > 0)
{
foreach (string aoption in adata)
{
string aoption_buffer = aoption.Trim().Replace("\"", "").Trim();
if (!String.IsNullOrEmpty(aoption_buffer))
{
attributeList.Add(aoption_buffer);
}
}
}
}
}
}
else if (babylonLine.IndexOf("uniforms", StringComparison.OrdinalIgnoreCase) >= 0)
{
string[] uniforms = babylonLine.Split(':');
if (uniforms != null && uniforms.Length > 1)
{
string ubuffer = uniforms[1].Replace("[", "").Replace("]", "");
if (!String.IsNullOrEmpty(ubuffer))
{
ubuffer = ubuffer.Trim();
string[] udata = ubuffer.Split(',');
if (udata != null && udata.Length > 0)
{
foreach (string uoption in udata)
{
string uoption_buffer = uoption.Trim().Replace("\"", "").Trim();
if (!String.IsNullOrEmpty(uoption_buffer))
{
uniformList.Add(uoption_buffer);
}
}
}
}
}
}
else if (babylonLine.IndexOf("samplers", StringComparison.OrdinalIgnoreCase) >= 0)
{
string[] samplers = babylonLine.Split(':');
if (samplers != null && samplers.Length > 1)
{
string sbuffer = samplers[1].Replace("[", "").Replace("]", "");
if (!String.IsNullOrEmpty(sbuffer))
{
sbuffer = sbuffer.Trim();
string[] sdata = sbuffer.Split(',');
if (sdata != null && sdata.Length > 0)
{
foreach (string soption in sdata)
{
string soption_buffer = soption.Trim().Replace("\"", "").Trim();
if (!String.IsNullOrEmpty(soption_buffer))
{
samplerList.Add(soption_buffer);
}
}
}
}
}
}
else if (babylonLine.IndexOf("defines", StringComparison.OrdinalIgnoreCase) >= 0)
{
string[] defines = babylonLine.Split(':');
if (defines != null && defines.Length > 1)
{
string dbuffer = defines[1].Replace("[", "").Replace("]", "");
if (!String.IsNullOrEmpty(dbuffer))
{
dbuffer = dbuffer.Trim();
string[] ddata = dbuffer.Split(',');
if (ddata != null && ddata.Length > 0)
{
foreach (string doption in ddata)
{
string doption_buffer = doption.Trim().Replace("\"", "").Trim();
if (!String.IsNullOrEmpty(doption_buffer))
{
defineList.Add(doption_buffer);
}
}
}
}
}
}
}
babylonShaderMaterial.options = new BabylonShaderOptions();
babylonShaderMaterial.options.attributes = attributeList.ToArray();
babylonShaderMaterial.options.uniforms = uniformList.ToArray();
babylonShaderMaterial.options.samplers = samplerList.ToArray();
babylonShaderMaterial.options.defines = defineList.ToArray();
string vertexProgram = GetShaderProgramSection(basename, program, BabylonProgramSection.Vertex);
var vertextFile = Path.Combine(outpath, basename + ".vertex.fx");
if (exportationOptions.EmbeddedShaders)
{
shaderpath.Add("vertexElement", ("base64:" + Tools.FormatBase64(vertexProgram)));
}
else
{
File.WriteAllText(vertextFile, vertexProgram);
}
string fragmentProgram = GetShaderProgramSection(basename, program, BabylonProgramSection.Fragment);
var fragmentFile = Path.Combine(outpath, basename + ".fragment.fx");
if (exportationOptions.EmbeddedShaders)
{
shaderpath.Add("fragmentElement", ("base64:" + Tools.FormatBase64(fragmentProgram)));
}
else
{
File.WriteAllText(fragmentFile, fragmentProgram);
}
babylonShaderMaterial.shaderPath = (exportationOptions.EmbeddedShaders) ? (object)shaderpath : (object)basename;
materialsDictionary.Add(babylonShaderMaterial.name, babylonShaderMaterial);
return babylonShaderMaterial;
}
static void SetMaterialKeywords(Material material)
{
// Note: keywords must be based on Material value not on MaterialProperty due to multi-edit & material animation
// (MaterialProperty value might come from renderer material property block)
SetKeyword (material, "_NORMALMAP", material.GetTexture ("_BumpMap") || material.GetTexture ("_DetailNormalMap"));
SpecularMode specularMode = ( SpecularMode )material.GetInt( "_SpecularMode" );
if ( specularMode == SpecularMode.BlinnPhong )
{
SetKeyword( material, "_SPECGLOSSMAP", material.GetTexture( "_SpecGlossMap" ) );
}
else if ( specularMode == SpecularMode.Metallic )
{
SetKeyword( material, "_METALLICGLOSSMAP", material.GetTexture( "_MetallicGlossMap" ) );
}
SetKeyword( material, "S_SPECULAR_NONE", specularMode == SpecularMode.None );
SetKeyword( material, "S_SPECULAR_BLINNPHONG", specularMode == SpecularMode.BlinnPhong );
SetKeyword( material, "S_SPECULAR_METALLIC", specularMode == SpecularMode.Metallic );
SetKeyword( material, "S_OCCLUSION", material.GetTexture("_OcclusionMap") );
SetKeyword( material, "_PARALLAXMAP", material.GetTexture("_ParallaxMap"));
SetKeyword( material, "_DETAIL_MULX2", material.GetTexture("_DetailAlbedoMap") || material.GetTexture("_DetailNormalMap"));
SetKeyword( material, "S_OVERRIDE_LIGHTMAP", material.GetTexture( "g_tOverrideLightmap" ) );
SetKeyword( material, "S_UNLIT", material.GetInt( "g_bUnlit" ) == 1 );
SetKeyword( material, "S_RECEIVE_SHADOWS", material.GetInt( "g_bReceiveShadows" ) == 1 );
SetKeyword( material, "S_WORLD_ALIGNED_TEXTURE", material.GetInt( "g_bWorldAlignedTexture" ) == 1 );
bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled (material.GetColor("_EmissionColor"));
SetKeyword (material, "_EMISSION", shouldEmissionBeEnabled);
if ( material.IsKeywordEnabled( "S_RENDER_BACKFACES" ) )
{
material.SetInt( "_Cull", ( int )UnityEngine.Rendering.CullMode.Off );
}
else
{
material.SetInt( "_Cull", ( int )UnityEngine.Rendering.CullMode.Back );
}
// Setup lightmap emissive flags
MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
{
flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
if (!shouldEmissionBeEnabled)
flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
material.globalIlluminationFlags = flags;
}
// Reflectance constants
float flReflectanceMin = material.GetFloat( "g_flReflectanceMin" );
float flReflectanceMax = material.GetFloat( "g_flReflectanceMax" );
material.SetFloat( "g_flReflectanceScale", Mathf.Max( flReflectanceMin, flReflectanceMax ) - flReflectanceMin );
material.SetFloat( "g_flReflectanceBias", flReflectanceMin );
// World aligned texture constants
Vector4 worldAlignedTextureNormal = material.GetVector( "g_vWorldAlignedTextureNormal" );
Vector3 normal = new Vector3( worldAlignedTextureNormal.x, worldAlignedTextureNormal.y, worldAlignedTextureNormal.z );
normal = ( normal.sqrMagnitude > 0.0f ) ? normal : Vector3.up;
Vector3 tangentU = Vector3.zero, tangentV = Vector3.zero;
Vector3.OrthoNormalize( ref normal, ref tangentU, ref tangentV );
material.SetVector( "g_vWorldAlignedNormalTangentU", new Vector4( tangentU.x, tangentU.y, tangentU.z, 0.0f ) );
material.SetVector( "g_vWorldAlignedNormalTangentV", new Vector4( tangentV.x, tangentV.y, tangentV.z, 0.0f ) );
// Static combo skips
if ( material.GetInt( "g_bUnlit" ) == 1 )
{
material.DisableKeyword( "_NORMALMAP" );
material.EnableKeyword( "S_SPECULAR_NONE" );
material.DisableKeyword( "S_SPECULAR_BLINNPHONG" );
material.DisableKeyword( "S_SPECULAR_METALLIC" );
material.DisableKeyword( "_METALLICGLOSSMAP" );
material.DisableKeyword( "_SPECGLOSSMAP" );
material.DisableKeyword( "S_OVERRIDE_LIGHTMAP" );
material.DisableKeyword( "S_RECEIVE_SHADOWS" );
}
}
private void SetEdgesKeywords(UnityEngine.Material material, string firstEdgeName, string secondEdgeName)
{
bool isSettingTopBottomEdgesKeywords = firstEdgeName == "Top";
bool areFirstSecondEdgesEnabled = material.GetInt("_Waterfall2D_Is" + firstEdgeName + secondEdgeName + "EdgesEnabled") == 1;
bool isFirstEdgeEnabled = material.GetInt("_Waterfall2D_Is" + firstEdgeName + "EdgeEnabled") == 1;
bool isSecondEdgeEnabled = material.GetInt("_Waterfall2D_Is" + secondEdgeName + "EdgeEnabled") == 1;
bool areFirstSecondEdgesUsingSameTexture = material.GetInt("_Waterfall2D_Is" + firstEdgeName + secondEdgeName + "EdgesUseSameTextureEnabled") == 1;
if (!areFirstSecondEdgesUsingSameTexture)
{
isFirstEdgeEnabled &= material.GetTexture("_" + firstEdgeName + "EdgeTexture") != null;
isSecondEdgeEnabled &= material.GetTexture("_" + secondEdgeName + "EdgeTexture") != null;
}
else
{
areFirstSecondEdgesEnabled &= material.GetTexture("_" + firstEdgeName + secondEdgeName + "EdgesTexture") != null;
}
bool isFirstSecondEdgesDistortionEffectEnabled = material.GetInt("_Waterfall2D_Is" + firstEdgeName + secondEdgeName + "EdgesNoiseEnabled") == 1;
bool isFirstEdgeTextureSheetEnabled = material.GetInt("_Waterfall2D_Is" + firstEdgeName + "EdgeTextureSheetEnabled") == 1;
bool isSecondEdgeTextureSheetEnabled = material.GetInt("_Waterfall2D_Is" + secondEdgeName + "EdgeTextureSheetEnabled") == 1;
bool isFirstSecondEdgesTextureSheetEnabled = material.GetInt("_Waterfall2D_Is" + firstEdgeName + secondEdgeName + "EdgesTextureSheetEnabled") == 1;
bool isFirstEdgeTextureSheetLerpEnabled = material.GetInt("_Waterfall2D_Is" + firstEdgeName + "EdgeTextureSheetWithLerpEnabled") == 1;
bool isSecondEdgeTextureSheetLerpEnabled = material.GetInt("_Waterfall2D_Is" + secondEdgeName + "EdgeTextureSheetWithLerpEnabled") == 1;
bool isFirstSecondEdgesTextureSheetLerpEnabled = material.GetInt("_Waterfall2D_Is" + firstEdgeName + secondEdgeName + "EdgesTextureSheetWithLerpEnabled") == 1;
Vector4 firstEdgeTextureTilingModeParameters = material.GetVector("_" + firstEdgeName + "EdgeTextureTilingParameters");
Vector4 secondEdgeTextureTilingModeParameters = material.GetVector("_" + secondEdgeName + "EdgeTextureTilingParameters");
Vector4 firstSecondEdgesTextureTilingModeParameters = material.GetVector("_" + firstEdgeName + secondEdgeName + "EdgesTextureTilingParameters");
bool isFirstEdgeTextureTilingModeSetToStretch = firstEdgeTextureTilingModeParameters.x == 1f;
bool isFirstEdgeTextureStretchTilingModeKeepAspect = firstEdgeTextureTilingModeParameters.y == 1f;
bool isFirstEdgeTextureStretchTilingModeAutoX = firstEdgeTextureTilingModeParameters.z == 1f;
bool isSecondEdgeTextureTilingModeSetToStretch = secondEdgeTextureTilingModeParameters.x == 1f;
bool isSecondEdgeTextureStretchTilingModeKeepAspect = secondEdgeTextureTilingModeParameters.y == 1f;
bool isSecondEdgeTextureStretchTilingModeAutoX = secondEdgeTextureTilingModeParameters.z == 1f;
bool isFirstSecondEdgesTextureTilingModeSetToStretch = firstSecondEdgesTextureTilingModeParameters.x == 1f;
bool isFirstSecondEdgesTextureStretchTilingModeKeepAspect = firstSecondEdgesTextureTilingModeParameters.y == 1f;
bool isFirstSecondEdgesTextureStretchTilingModeAutoX = firstSecondEdgesTextureTilingModeParameters.z == 1f;
Vector4 textureFlippingParametes = material.GetVector("_" + firstEdgeName + secondEdgeName + "EdgesTextureFlipParameters");
bool isTextureFlippingEnabled = textureFlippingParametes.x == 1f;
bool isTextureFlippingFirstEdge = textureFlippingParametes.y == 1f;
bool isFirstSecondEdgesAbsoluteThicknessAndOffsetAbsolute = material.GetInt("_Waterfall2D_Is" + firstEdgeName + secondEdgeName + "EdgesAbsoluteThicknessAndOffsetEnabled") == 1;
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + secondEdgeName + "EdgesSameTexture", areFirstSecondEdgesEnabled && isFirstEdgeEnabled && isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture && !isFirstSecondEdgesTextureSheetEnabled && !(isFirstSecondEdgesTextureSheetEnabled && isFirstSecondEdgesTextureSheetLerpEnabled));
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + secondEdgeName + "EdgesSameTextureSheet", areFirstSecondEdgesEnabled && isFirstEdgeEnabled && isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture && isFirstSecondEdgesTextureSheetEnabled && !isFirstSecondEdgesTextureSheetLerpEnabled);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + secondEdgeName + "EdgesSameTextureSheetWithLerp", areFirstSecondEdgesEnabled && isFirstEdgeEnabled && isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture && isFirstSecondEdgesTextureSheetEnabled && isFirstSecondEdgesTextureSheetLerpEnabled);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + "Edge", areFirstSecondEdgesEnabled && isFirstEdgeEnabled && !(isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture) && !isFirstEdgeTextureSheetEnabled && !(isFirstEdgeTextureSheetEnabled && isFirstEdgeTextureSheetLerpEnabled));
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + "EdgeTextureSheet", areFirstSecondEdgesEnabled && isFirstEdgeEnabled && !(isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture) && isFirstEdgeTextureSheetEnabled && !isFirstEdgeTextureSheetLerpEnabled);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + "EdgeTextureSheetWithLerp", areFirstSecondEdgesEnabled && isFirstEdgeEnabled && !(isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture) && isFirstEdgeTextureSheetEnabled && isFirstEdgeTextureSheetLerpEnabled);
SetKeywordState(material, "Waterfall2D_" + secondEdgeName + "Edge", areFirstSecondEdgesEnabled && isSecondEdgeEnabled && !(isFirstEdgeEnabled && areFirstSecondEdgesUsingSameTexture) && !isSecondEdgeTextureSheetEnabled && !(isSecondEdgeTextureSheetEnabled && isSecondEdgeTextureSheetLerpEnabled));
SetKeywordState(material, "Waterfall2D_" + secondEdgeName + "EdgeTextureSheet", areFirstSecondEdgesEnabled && isSecondEdgeEnabled && !(isFirstEdgeEnabled && areFirstSecondEdgesUsingSameTexture) && isSecondEdgeTextureSheetEnabled && !isSecondEdgeTextureSheetLerpEnabled);
SetKeywordState(material, "Waterfall2D_" + secondEdgeName + "EdgeTextureSheetWithLerp", areFirstSecondEdgesEnabled && isSecondEdgeEnabled && !(isFirstEdgeEnabled && areFirstSecondEdgesUsingSameTexture) && isSecondEdgeTextureSheetEnabled && isSecondEdgeTextureSheetLerpEnabled);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + secondEdgeName + "EdgesNoise", areFirstSecondEdgesEnabled && (isFirstEdgeEnabled || isSecondEdgeEnabled) && isFirstSecondEdgesDistortionEffectEnabled);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + "EdgeTextureStretch", areFirstSecondEdgesEnabled && isFirstEdgeEnabled && !(isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture) && isFirstEdgeTextureTilingModeSetToStretch && !isFirstEdgeTextureStretchTilingModeKeepAspect);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + "EdgeTextureStretchAutoX", areFirstSecondEdgesEnabled && isFirstEdgeEnabled && !(isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture) && isFirstEdgeTextureTilingModeSetToStretch && isFirstEdgeTextureStretchTilingModeKeepAspect && isFirstEdgeTextureStretchTilingModeAutoX);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + "EdgeTextureStretchAutoY", areFirstSecondEdgesEnabled && isFirstEdgeEnabled && !(isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture) && isFirstEdgeTextureTilingModeSetToStretch && isFirstEdgeTextureStretchTilingModeKeepAspect && !isFirstEdgeTextureStretchTilingModeAutoX);
SetKeywordState(material, "Waterfall2D_" + secondEdgeName + "EdgeTextureStretch", areFirstSecondEdgesEnabled && isSecondEdgeEnabled && !(isFirstEdgeEnabled && areFirstSecondEdgesUsingSameTexture) && isSecondEdgeTextureTilingModeSetToStretch && !isSecondEdgeTextureStretchTilingModeKeepAspect);
SetKeywordState(material, "Waterfall2D_" + secondEdgeName + "EdgeTextureStretchAutoX", areFirstSecondEdgesEnabled && isSecondEdgeEnabled && !(isFirstEdgeEnabled && areFirstSecondEdgesUsingSameTexture) && isSecondEdgeTextureTilingModeSetToStretch && isSecondEdgeTextureStretchTilingModeKeepAspect && isSecondEdgeTextureStretchTilingModeAutoX);
SetKeywordState(material, "Waterfall2D_" + secondEdgeName + "EdgeTextureStretchAutoY", areFirstSecondEdgesEnabled && isSecondEdgeEnabled && !(isFirstEdgeEnabled && areFirstSecondEdgesUsingSameTexture) && isSecondEdgeTextureTilingModeSetToStretch && isSecondEdgeTextureStretchTilingModeKeepAspect && !isSecondEdgeTextureStretchTilingModeAutoX);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + secondEdgeName + "EdgesTextureStretch", areFirstSecondEdgesEnabled && isFirstEdgeEnabled && isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture && isFirstSecondEdgesTextureTilingModeSetToStretch && !isFirstSecondEdgesTextureStretchTilingModeKeepAspect);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + secondEdgeName + "EdgesTextureStretchAutoX", areFirstSecondEdgesEnabled && isFirstEdgeEnabled && isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture && isFirstSecondEdgesTextureTilingModeSetToStretch && isFirstSecondEdgesTextureStretchTilingModeKeepAspect && isFirstSecondEdgesTextureStretchTilingModeAutoX);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + secondEdgeName + "EdgesTextureStretchAutoY", areFirstSecondEdgesEnabled && isFirstEdgeEnabled && isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture && isFirstSecondEdgesTextureTilingModeSetToStretch && isFirstSecondEdgesTextureStretchTilingModeKeepAspect && !isFirstSecondEdgesTextureStretchTilingModeAutoX);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + secondEdgeName + "EdgesFlip" + firstEdgeName + "Edge" + (isSettingTopBottomEdgesKeywords ? "Y" : "X"), areFirstSecondEdgesEnabled && isFirstEdgeEnabled && isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture && isTextureFlippingEnabled && isTextureFlippingFirstEdge);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + secondEdgeName + "EdgesFlip" + secondEdgeName + "Edge" + (isSettingTopBottomEdgesKeywords ? "Y" : "X"), areFirstSecondEdgesEnabled && isFirstEdgeEnabled && isSecondEdgeEnabled && areFirstSecondEdgesUsingSameTexture && isTextureFlippingEnabled && !isTextureFlippingFirstEdge);
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + secondEdgeName + "EdgesAbsoluteThicknessAndOffset", areFirstSecondEdgesEnabled && (isFirstEdgeEnabled || isSecondEdgeEnabled) && isFirstSecondEdgesAbsoluteThicknessAndOffsetAbsolute);
if (!isSettingTopBottomEdgesKeywords)
{
bool isTextureAlphaCutoffEnabled = FindProperty("_Waterfall2D_Is" + firstEdgeName + secondEdgeName + "EdgesTextureAlphaCutoffEnabled", _materialProperties).floatValue == 1f;
SetKeywordState(material, "Waterfall2D_" + firstEdgeName + secondEdgeName + "EdgesTextureAlphaCutoff", (areFirstSecondEdgesEnabled || isFirstEdgeEnabled || isSecondEdgeEnabled) && isTextureAlphaCutoffEnabled);
}
}
public static ByteBuffer Save(UnityEngine.Material material)
{
FlatBufferBuilder builder = new FlatBufferBuilder(InitBufferSize);
int count = ShaderUtil.GetPropertyCount(material.shader);
List <Offset <ShaderProperty> > listOffShaderProperties = new List <Offset <ShaderProperty> >();
for (int i = 0; i < count; i++)
{
string name = ShaderUtil.GetPropertyName(material.shader, i);
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(material.shader, i);
Schema.ShaderPropertyValue valueType = ShaderPropertyValue.NONE;
int valueOffset = -1;
switch (type)
{
case ShaderUtil.ShaderPropertyType.Color:
{
UnityEngine.Color c = material.GetColor(name);
ShaderPropertyColor.StartShaderPropertyColor(builder);
ShaderPropertyColor.AddColor(builder, Schema.Color.CreateColor(builder, c.a, c.b, c.g, c.r));
Offset <ShaderPropertyColor> offset = ShaderPropertyColor.EndShaderPropertyColor(builder);
valueType = ShaderPropertyValue.ShaderPropertyColor;
valueOffset = offset.Value;
}
break;
case ShaderUtil.ShaderPropertyType.Vector:
{
Vector4 v = material.GetVector(name);
ShaderPropertyVector.StartShaderPropertyVector(builder);
ShaderPropertyVector.AddVector(builder, Schema.Vec4.CreateVec4(builder, v.x, v.y, v.z, v.w));
Offset <ShaderPropertyVector> offset = ShaderPropertyVector.EndShaderPropertyVector(builder);
valueType = ShaderPropertyValue.ShaderPropertyVector;
valueOffset = offset.Value;
}
break;
case ShaderUtil.ShaderPropertyType.Range:
case ShaderUtil.ShaderPropertyType.Float:
{
float f = material.GetFloat(name);
ShaderPropertyFloat.StartShaderPropertyFloat(builder);
ShaderPropertyFloat.AddValue(builder, f);
Offset <ShaderPropertyFloat> offset = ShaderPropertyFloat.EndShaderPropertyFloat(builder);
valueType = ShaderPropertyValue.ShaderPropertyFloat;
valueOffset = offset.Value;
}
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
{
UnityEngine.Texture t = material.GetTexture(name);
string textureName = "$NULL_TEXTURE";
if (t != null)
{
textureName = AssetDatabase.GetAssetPath(t.GetInstanceID());
if (string.IsNullOrEmpty(textureName))
{
textureName = t.name;
}
else
{
textureName = textureName.Substring(ArtWork.path.Length);
textureName = System.IO.Path.GetDirectoryName(textureName) + "/" + System.IO.Path.GetFileNameWithoutExtension(textureName);
}
}
Vector2 toffset = material.GetTextureOffset(name);
Vector2 tscale = material.GetTextureScale(name);
StringOffset pathOffset = builder.CreateString(textureName);
ShaderPropertyTexture.StartShaderPropertyTexture(builder);
ShaderPropertyTexture.AddName(builder, pathOffset);
ShaderPropertyTexture.AddOffset(builder, Vec2.CreateVec2(builder, toffset.x, toffset.y));
ShaderPropertyTexture.AddScale(builder, Vec2.CreateVec2(builder, tscale.x, tscale.y));
Offset <ShaderPropertyTexture> offset = ShaderPropertyTexture.EndShaderPropertyTexture(builder);
valueType = ShaderPropertyValue.ShaderPropertyTexture;
valueOffset = offset.Value;
}
break;
}
if (valueOffset >= 0)
{
listOffShaderProperties.Add(
ShaderProperty.CreateShaderProperty(
builder, builder.CreateString(name), (Schema.ShaderPropertyType)type, valueType, valueOffset
));
}
}
StringOffset offMaterialName = builder.CreateString(material.name);
StringOffset offShader = builder.CreateString(material.shader.name);
Offset <Schema.Material> offMaterial = Schema.Material.CreateMaterial(
builder, offMaterialName, offShader, Schema.Material.CreatePropertiesVector(builder, listOffShaderProperties.ToArray()));
builder.Finish(offMaterial.Value);
return(builder.DataBuffer);
}
private void Awake()
{
m_material = GetComponent<Renderer>().sharedMaterial;
// Actual water rendering mode depends on both the current setting AND
// the hardware support. There's no point in rendering refraction textures
// if they won't be visible in the end.
m_HardwareWaterSupport = FindHardwareWaterSupport ();
//m_waterMode = GetWaterMode ();
m_waveSpeed = m_material.GetVector ("WaveSpeed");
m_waveScale = m_material.GetFloat ("_WaveScale");
m_waveScale4 = new Vector4 (m_waveScale, m_waveScale, m_waveScale * 0.4f, m_waveScale * 0.45f);
m_material.SetVector ("_WaveScale4", m_waveScale4);
m_xWaveSpeedScaled = m_waveSpeed.x * m_waveScale4.x;
m_yWaveSpeedScaled = m_waveSpeed.y * m_waveScale4.y;
m_zWaveSpeedScaled = m_waveSpeed.z * m_waveScale4.z;
m_wWaveSpeedScaled = m_waveSpeed.w * m_waveScale4.w;
m_camera = Camera.current;
// CreateWaterObjects (m_camera, out m_reflectionCamera, out m_refractionCamera);
// UpdateCameraModes (m_camera, m_reflectionCamera);
// UpdateCameraModes (m_camera, m_refractionCamera);
}
public static GLTF.Schema.Material ConvertSeinCustomMaterial(UnityEngine.Material mat, ExporterEntry entry)
{
if (_tempGO == null)
{
_tempGO = new GameObject();
}
var customMaterial = _tempGO.AddComponent <SeinCustomMaterial>();
var className = mat.shader.name.Replace("Sein/", "");
if (!className.Contains("Material"))
{
className += "Material";
}
var shaderPath = AssetDatabase.GetAssetPath(mat.shader);
if (shaderPath != null)
{
var matScriptPath = Path.Combine(
shaderPath.Replace(Path.GetFileName(shaderPath), ""),
className + ".js"
);
if (File.Exists(matScriptPath))
{
if (entry.root.Extensions == null)
{
entry.root.Extensions = new Dictionary <string, Extension>();
}
customMaterial.matScriptPath = matScriptPath;
}
}
customMaterial.className = className;
customMaterial.renderOrder = mat.renderQueue;
customMaterial.unityMaterialName = mat.name;
var floatArray = new List <SeinMaterialUniformFloat>();
var vector4Array = new List <SeinMaterialUniformFloatVec4>();
var colorArray = new List <SeinMaterialUniformColor>();
var textureArray = new List <SeinMaterialUniformTexture>();
for (int i = 0; i < ShaderUtil.GetPropertyCount(mat.shader); i += 1)
{
var propType = ShaderUtil.GetPropertyType(mat.shader, i);
var propName = ShaderUtil.GetPropertyName(mat.shader, i);
if (propName == "cloneForInst")
{
customMaterial.cloneForInst = mat.GetInt("cloneForInst") != 0;
continue;
}
if (ShaderUtil.IsShaderPropertyHidden(mat.shader, i))
{
continue;
}
var n = propName;
switch (propType)
{
case ShaderUtil.ShaderPropertyType.Float:
case ShaderUtil.ShaderPropertyType.Range:
floatArray.Add(new SeinMaterialUniformFloat {
name = propName, value = mat.GetFloat(n)
});
break;
case ShaderUtil.ShaderPropertyType.Color:
colorArray.Add(new SeinMaterialUniformColor {
name = propName, value = mat.GetColor(n)
});
break;
case ShaderUtil.ShaderPropertyType.Vector:
vector4Array.Add(new SeinMaterialUniformFloatVec4 {
name = propName, value = mat.GetVector(n)
});
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
if (mat.GetTexture(n) != null)
{
textureArray.Add(new SeinMaterialUniformTexture {
name = propName, value = (Texture2D)mat.GetTexture(n)
});
}
break;
}
customMaterial.uniformsFloat = floatArray.ToArray();
customMaterial.uniformsFloatVec4 = vector4Array.ToArray();
customMaterial.uniformsColor = colorArray.ToArray();
customMaterial.uniformsTexture = textureArray.ToArray();
}
var tempM = new GLTF.Schema.Material();
customMaterial.transparent = ProcessTransparency(mat, tempM);
var m = ConvertMaterial(customMaterial, entry);
return(m);
}
static JsonData getUnityMatData(UnityEngine.Material mat, Paladin paladin = null)
{
var ret = new JsonData();
ret["type"] = mat.name;
var param = new JsonData();
var albedo = new JsonData();
var color = Util.fromColor(mat.GetColor("_Color"));
albedo.Add(color);
var uvOffset = mat.GetVector("_MainTex_ST");
var mainTex = mat.GetTexture("_MainTex");
var texData = new JsonData();
if (mainTex != null)
{
texData["type"] = "image";
var srcFn = AssetDatabase.GetAssetPath(mainTex);
var idx = srcFn.LastIndexOf("/");
var dstFn = paladin.outputDir + "/" + paladin.outputName + srcFn.Substring(idx);
var fn = srcFn.Substring(idx + 1);
if (!File.Exists(dstFn))
{
FileUtil.CopyFileOrDirectory(srcFn, dstFn);
}
texData["param"] = new JsonData();
texData["subtype"] = "spectrum";
if (uvOffset != null)
{
texData["param"]["uvOffset"] = Util.fromVec4(uvOffset);
}
texData["param"]["fileName"] = fn;
texData["param"]["fromBasePath"] = true;
}
else
{
texData.Add(1);
texData.Add(1);
texData.Add(1);
}
albedo.Add(texData);
param["albedo"] = albedo;
param["bumpScale"] = mat.GetFloat("_BumpScale");
var emission = mat.GetColor("_EmissionColor");
if (emission != null)
{
var emissionData = new JsonData();
param["emission"] = emissionData;
emissionData["Le"] = new JsonData();
emissionData["Le"]["colorType"] = 1;
emissionData["Le"]["color"] = Util.fromColor(emission);
}
var normalMap = mat.GetTexture("_BumpMap");
if (normalMap != null)
{
var normalMapData = new JsonData();
var srcFn = AssetDatabase.GetAssetPath(normalMap);
var idx = srcFn.LastIndexOf("/");
var dstFn = paladin.outputDir + "/" + paladin.outputName + srcFn.Substring(idx);
var fn = srcFn.Substring(idx + 1);
if (!File.Exists(dstFn))
{
FileUtil.CopyFileOrDirectory(srcFn, dstFn);
}
normalMapData["param"] = new JsonData();
normalMapData["subtype"] = "spectrum";
normalMapData["type"] = "image";
normalMapData["param"]["fileName"] = fn;
normalMapData["param"]["fromBasePath"] = true;
if (uvOffset != null)
{
normalMapData["param"]["uvOffset"] = Util.fromVec4(uvOffset);
}
param["normalMap"] = normalMapData;
}
var bumpMap = mat.GetTexture("_ParallaxMap");
if (bumpMap != null)
{
var bumpMapData = new JsonData();
var srcFn = AssetDatabase.GetAssetPath(bumpMap);
var idx = srcFn.LastIndexOf("/");
var dstFn = paladin.outputDir + "/" + paladin.outputName + srcFn.Substring(idx);
var fn = srcFn.Substring(idx + 1);
if (!File.Exists(dstFn))
{
FileUtil.CopyFileOrDirectory(srcFn, dstFn);
}
bumpMapData["param"] = new JsonData();
bumpMapData["subtype"] = "spectrum";
bumpMapData["type"] = "image";
bumpMapData["param"]["fileName"] = fn;
bumpMapData["param"]["fromBasePath"] = true;
if (uvOffset != null)
{
bumpMapData["param"]["uvOffset"] = Util.fromVec4(uvOffset);
}
param["bumpMap"] = bumpMapData;
}
param["roughness"] = 1 - mat.GetFloat("_Glossiness");
param["metallic"] = mat.GetFloat("_Metallic");
ret["param"] = param;
return(ret);
}
private void CloneToBuffer(Material mat, CommandBuffer buf)
{
foreach (KeyValuePair<object, object> field in cache)
{
object obj = field.Value;
//float
int id = (int)field.Key;
if (obj.GetType() == typeof(float))
{
float value = mat.GetFloat(id);
buf.SetGlobalFloat(id, value);
}
//Color
else if (obj.GetType() == typeof(Color))
{
Color value = mat.GetColor(id);
buf.SetGlobalColor(id, value);
}
//Color32
else if (obj.GetType() == typeof(Color32))
{
Color value = mat.GetColor(id);
buf.SetGlobalColor(id, value);
}//Vector2
else if (obj.GetType() == typeof(Vector2))
{
Vector4 value = mat.GetVector(id);
buf.SetGlobalVector(id, value);
}
//Vector3
else if (obj.GetType() == typeof(Vector3))
{
Vector4 value = mat.GetVector(id);
buf.SetGlobalVector(id, value);
}
//Vector4
else if (obj.GetType() == typeof(Vector4))
{
Vector4 value = mat.GetVector(id);
buf.SetGlobalVector(id, value);
}
//Matrix
else if (obj.GetType() == typeof(Matrix4x4))
{
Matrix4x4 value = mat.GetMatrix(id);
buf.SetGlobalMatrix(id, value);
}
}
}
public void SetToToCurrent()
{
if (_material = material)
{
to = _material.GetVector(propertyID);
}
}
public static Texture2D BuildPreviewTexture(int width, int height, Sprite sprite, Material spriteRendererMaterial, bool isPolygon)
{
if (!ShaderUtil.hardwareSupportsRectRenderTexture)
{
return null;
}
float num = sprite.rect.width;
float num2 = sprite.rect.height;
Texture2D spriteTexture = SpriteUtility.GetSpriteTexture(sprite, false);
if (!isPolygon)
{
PreviewHelpers.AdjustWidthAndHeightForStaticPreview((int) num, (int) num2, ref width, ref height);
}
SavedRenderTargetState state = new SavedRenderTargetState();
RenderTexture temp = RenderTexture.GetTemporary(width, height, 0, RenderTextureFormat.Default, RenderTextureReadWrite.Default);
RenderTexture.active = temp;
GL.sRGBWrite = QualitySettings.activeColorSpace == ColorSpace.Linear;
GL.Clear(true, true, new Color(0f, 0f, 0f, 0f));
Texture texture = null;
Vector4 vector = new Vector4(0f, 0f, 0f, 0f);
bool flag = false;
bool flag2 = false;
if (spriteRendererMaterial != null)
{
flag = spriteRendererMaterial.HasProperty("_MainTex");
flag2 = spriteRendererMaterial.HasProperty("_MainTex_TexelSize");
}
Material material = null;
if (spriteRendererMaterial != null)
{
if (flag)
{
texture = spriteRendererMaterial.GetTexture("_MainTex");
spriteRendererMaterial.SetTexture("_MainTex", spriteTexture);
}
if (flag2)
{
vector = spriteRendererMaterial.GetVector("_MainTex_TexelSize");
spriteRendererMaterial.SetVector("_MainTex_TexelSize", TextureUtil.GetTexelSizeVector(spriteTexture));
}
spriteRendererMaterial.SetPass(0);
}
else
{
material = new Material(Shader.Find("Hidden/BlitCopy")) {
mainTexture = spriteTexture,
mainTextureScale = Vector2.one,
mainTextureOffset = Vector2.zero
};
material.SetPass(0);
}
float num3 = sprite.rect.width / sprite.bounds.size.x;
Vector2[] vertices = sprite.vertices;
Vector2[] uv = sprite.uv;
ushort[] triangles = sprite.triangles;
Vector2 pivot = sprite.pivot;
GL.PushMatrix();
GL.LoadOrtho();
GL.Color(new Color(1f, 1f, 1f, 1f));
GL.Begin(4);
for (int i = 0; i < triangles.Length; i++)
{
ushort index = triangles[i];
Vector2 vector4 = vertices[index];
Vector2 vector5 = uv[index];
GL.TexCoord(new Vector3(vector5.x, vector5.y, 0f));
GL.Vertex3(((vector4.x * num3) + pivot.x) / num, ((vector4.y * num3) + pivot.y) / num2, 0f);
}
GL.End();
GL.PopMatrix();
GL.sRGBWrite = false;
if (spriteRendererMaterial != null)
{
if (flag)
{
spriteRendererMaterial.SetTexture("_MainTex", texture);
}
if (flag2)
{
spriteRendererMaterial.SetVector("_MainTex_TexelSize", vector);
}
}
Texture2D textured3 = new Texture2D(width, height, TextureFormat.RGBA32, false) {
hideFlags = HideFlags.HideAndDontSave,
filterMode = spriteTexture.filterMode,
anisoLevel = spriteTexture.anisoLevel,
wrapMode = spriteTexture.wrapMode
};
textured3.ReadPixels(new Rect(0f, 0f, (float) width, (float) height), 0, 0);
textured3.Apply();
RenderTexture.ReleaseTemporary(temp);
state.Restore();
if (material != null)
{
Object.DestroyImmediate(material);
}
return textured3;
}
// Use this for initialization
void Start()
{
waveScale = new Vector3 ();
_mat = GetComponent<Renderer>().sharedMaterial;
steepness = _mat.GetVector ("_GSteepness");
amplitude = _mat.GetVector ("_GAmplitude");
frequency = _mat.GetVector ("_GFrequency");
speed = _mat.GetVector ("_GSpeed");
dirAB = _mat.GetVector ("_GDirectionAB");
dirCD = _mat.GetVector ("_GDirectionCD");
//waveScale = _mat.GetVector("_WaveScale");
}
void UpdateMaterial(Material m)
{
Vector3 d1 = m.GetVector("_Direction1");
Vector3 d2 = m.GetVector("_Direction2");
Vector3 d3 = m.GetVector("_Direction3");
Vector3 d4 = m.GetVector("_Direction4");
m.SetVector("_NormalizedVector1", d1.normalized);
m.SetVector("_NormalizedVector2", d2.normalized);
m.SetVector("_NormalizedVector3", d3.normalized);
m.SetVector("_NormalizedVector4", d4.normalized);
}
private void UpdateCurrentWater()
{
if (Boat != null)
{
Boat.SetActive(false);
Boat.SetActive(true);
}
startSunIntencity = Sun.intensity;
currentWater = GameObject.Find("Water");
currentWaterMaterial = currentWater.GetComponent<Renderer>().material;
refl = currentWaterMaterial.GetColor("_ReflectionColor").r;
if (!IsMobileScene) transparent = currentWaterMaterial.GetFloat("_DepthTransperent");
if (!IsMobileScene) fadeBlend = currentWaterMaterial.GetFloat("_FadeDepth");
refraction = currentWaterMaterial.GetFloat("_Distortion");
oldTextureScale = currentWaterMaterial.GetFloat("_TexturesScale");
oldWaveScale = currentWaterMaterial.GetFloat("_WaveScale");
var infiniteMesh = GameObject.Find("InfiniteWaterMesh");
if (infiniteMesh != null) infiniteMesh.GetComponent<Renderer>().material = currentWaterMaterial;
var projectorCausticScale = GameObject.Find("ProjectorCausticScale");
if (projectorCausticScale != null) oldCausticScale = projectorCausticScale.transform.localScale;
caustic = GameObject.Find("Caustic");
if (IsMobileScene) caustic.SetActive(false);
if (!IsMobileScene) causticMaterial = caustic.GetComponent<Projector>().material;
waterDirection = currentWaterMaterial.GetVector("_Direction");
if (!IsMobileScene) foamDirection = currentWaterMaterial.GetVector("_FoamDirection");
if (!IsMobileScene) causticDirection = causticMaterial.GetVector("_CausticDirection");
ABDirection = currentWaterMaterial.GetVector("_GDirectionAB");
CDDirection = currentWaterMaterial.GetVector("_GDirectionCD");
}
protected override void SetMaterialKeywords(UnityEngine.Material material)
{
bool applyTintOnTopOfTexture = material.GetFloat("_Water2D_IsApplyTintColorOnTopOfTextureEnabled") == 1f;
SetKeywordState(material, "Water2D_ApplyTintColorBeforeTexture", !applyTintOnTopOfTexture);
//Water Body Keywords
bool hasWaterBodyTexture = material.GetTexture("_WaterTexture") != null;
bool isWaterBodyTextureSheetEnabled = material.GetFloat("_Water2D_IsWaterTextureSheetEnabled") == 1.0f;
bool isWaterBodyTextureSheetWithLerpEnabled = material.GetFloat("_Water2D_IsWaterTextureSheetWithLerpEnabled") == 1.0;
Vector4 waterBodyTextureTilingParameters = material.GetVector("_WaterTextureTilingParameters");
bool isWaterBodyTextureTilingModeSetToStretch = waterBodyTextureTilingParameters.x == 1f;
bool isWaterBodyTextureStretchTilingModeKeepAspect = waterBodyTextureTilingParameters.y == 1f;
bool isWaterBodyTextureStretchTilingModeAutoX = waterBodyTextureTilingParameters.z == 1f;
bool isWaterBodyTextureScrollingEnabled = material.GetFloat("_WaterTextureScrollingSpeedX") != 0f || material.GetFloat("_WaterTextureScrollingSpeedY") != 0f;
SetKeywordState(material, "Water2D_WaterTexture", hasWaterBodyTexture && !isWaterBodyTextureSheetEnabled);
SetKeywordState(material, "Water2D_WaterTextureSheet", hasWaterBodyTexture && isWaterBodyTextureSheetEnabled && !isWaterBodyTextureSheetWithLerpEnabled);
SetKeywordState(material, "Water2D_WaterTextureSheetWithLerp", hasWaterBodyTexture && isWaterBodyTextureSheetEnabled && isWaterBodyTextureSheetWithLerpEnabled);
SetKeywordState(material, "Water2D_WaterNoise", hasWaterBodyTexture && material.GetFloat("_Water2D_IsWaterNoiseEnabled") == 1.0f);
SetKeywordState(material, "Water2D_WaterTextureStretch", hasWaterBodyTexture && isWaterBodyTextureTilingModeSetToStretch && !isWaterBodyTextureStretchTilingModeKeepAspect);
SetKeywordState(material, "Water2D_WaterTextureStretchAutoX", hasWaterBodyTexture && isWaterBodyTextureTilingModeSetToStretch && isWaterBodyTextureStretchTilingModeKeepAspect && isWaterBodyTextureStretchTilingModeAutoX);
SetKeywordState(material, "Water2D_WaterTextureStretchAutoY", hasWaterBodyTexture && isWaterBodyTextureTilingModeSetToStretch && isWaterBodyTextureStretchTilingModeKeepAspect && !isWaterBodyTextureStretchTilingModeAutoX);
SetKeywordState(material, "Water2D_ColorGradient", material.GetFloat("_Water2D_IsColorGradientEnabled") == 1.0f);
SetKeywordState(material, "Water2D_WaterTextureScroll", hasWaterBodyTexture && isWaterBodyTextureScrollingEnabled);
//Refraction & Reflection Keywords
bool isReflectionEnabled = material.GetFloat("_Water2D_IsReflectionEnabled") == 1.0f;
bool isRefractionEnabled = material.GetFloat("_Water2D_IsRefractionEnabled") == 1.0f;
Vector4 reflectionFadingParameters = material.GetVector("_ReflectionFadingParameters");
bool isReflectionFadingEnabled = reflectionFadingParameters.x == 1f;
SetKeywordState(material, "Water2D_Refraction", isRefractionEnabled);
SetKeywordState(material, "Water2D_Reflection", isReflectionEnabled);
SetKeywordState(material, "Water2D_ReflectionFadeLinear", isReflectionEnabled && isReflectionFadingEnabled && reflectionFadingParameters.y == 0f);
SetKeywordState(material, "Water2D_ReflectionFadeExponentialTwo", isReflectionEnabled && isReflectionFadingEnabled && reflectionFadingParameters.y == 1f);
SetKeywordState(material, "Water2D_ReflectionFadeExponentialThree", isReflectionEnabled && isReflectionFadingEnabled && reflectionFadingParameters.y == 2f);
SetKeywordState(material, "Water2D_ReflectionFadeExponentialFour", isReflectionEnabled && isReflectionFadingEnabled && reflectionFadingParameters.y == 3f);
//Water Surface Keywords
bool isSurfaceEnabled = material.GetFloat("_Water2D_IsSurfaceEnabled") == 1.0f;
bool hasSurfaceTexture = material.GetTexture("_SurfaceTexture") != null;
bool isSurfaceTextureSheetEnabled = material.GetFloat("_Water2D_IsWaterSurfaceTextureSheetEnabled") == 1.0f;
bool isSurfaceTextureSheetWithLerpEnbaled = material.GetFloat("_Water2D_IsWaterSurfaceTextureSheetWithLerpEnabled") == 1.0f;
Vector4 waterSurfaceTextureTilingParameters = material.GetVector("_SurfaceTextureTilingParameters");
bool isSurfaceTextureTilingModeSetToStretch = waterSurfaceTextureTilingParameters.x == 1f;
bool isSurfaceTextureStretchTilingModeKeepAspect = waterSurfaceTextureTilingParameters.y == 1f;
bool isSurfaceTextureStretchTilingModeAutoX = waterSurfaceTextureTilingParameters.z == 1f;
bool isSurfaceTextureScrollingEnabled = material.GetFloat("_SurfaceTextureScrollingSpeedX") != 0f || material.GetFloat("_SurfaceTextureScrollingSpeedY") != 0f;
SetKeywordState(material, "Water2D_Surface", isSurfaceEnabled);
SetKeywordState(material, "Water2D_SurfaceTexture", isSurfaceEnabled && hasSurfaceTexture && !isSurfaceTextureSheetEnabled);
SetKeywordState(material, "Water2D_SurfaceTextureSheet", isSurfaceEnabled && hasSurfaceTexture && isSurfaceTextureSheetEnabled && !isSurfaceTextureSheetWithLerpEnbaled);
SetKeywordState(material, "Water2D_SurfaceTextureSheetWithLerp", isSurfaceEnabled && hasSurfaceTexture && isSurfaceTextureSheetEnabled && isSurfaceTextureSheetWithLerpEnbaled);
SetKeywordState(material, "Water2D_SurfaceNoise", isSurfaceEnabled && hasSurfaceTexture && material.GetFloat("_Water2D_IsSurfaceNoiseEnabled") == 1.0f);
SetKeywordState(material, "Water2D_SurfaceTextureStretch", isSurfaceEnabled && hasSurfaceTexture && isSurfaceTextureTilingModeSetToStretch && !isSurfaceTextureStretchTilingModeKeepAspect);
SetKeywordState(material, "Water2D_SurfaceTextureStretchAutoX", isSurfaceEnabled && hasSurfaceTexture && isSurfaceTextureTilingModeSetToStretch && isSurfaceTextureStretchTilingModeKeepAspect && isSurfaceTextureStretchTilingModeAutoX);
SetKeywordState(material, "Water2D_SurfaceTextureStretchAutoY", isSurfaceEnabled && hasSurfaceTexture && isSurfaceTextureTilingModeSetToStretch && isSurfaceTextureStretchTilingModeKeepAspect && !isSurfaceTextureStretchTilingModeAutoX);
SetKeywordState(material, "Water2D_SurfaceColorGradient", isSurfaceEnabled && material.GetFloat("_Water2D_IsSurfaceColorGradientEnabled") == 1.0f);
SetKeywordState(material, "Water2D_SurfaceTextureScroll", isSurfaceEnabled && hasSurfaceTexture && isSurfaceTextureScrollingEnabled);
//Water Fake Perspective
bool isFakePerspectiveEnabled = isSurfaceEnabled && (isRefractionEnabled || isReflectionEnabled) && (material.GetFloat("_Water2D_IsFakePerspectiveEnabled") == 1.0f);
SetKeywordState(material, "Water2D_FakePerspective", isFakePerspectiveEnabled);
//Lighting keywords
SetKeywordState(material, "Water2D_ApplyEmissionColor", material.GetFloat("_Water2D_IsEmissionColorEnabled") == 1.0f);
}
public void EqualSource()
{
UnityEngine.Material realMaterial = resultMaterial.Unity3dObject as UnityEngine.Material;
Assert.AreEqual(material.Name, realMaterial.name);
Assert.AreEqual(material.Shader, realMaterial.shader.name);
for (int i = 0; i < material.PropertiesLength; i++)
{
Schema.ShaderProperty p = material.GetProperties(i);
Assert.IsTrue(realMaterial.HasProperty(p.Names));
switch (p.Type)
{
case ShaderPropertyType.Float:
case ShaderPropertyType.Range:
{
Assert.AreEqual(p.ValueType, ShaderPropertyValue.ShaderPropertyFloat);
float originValue = realMaterial.GetFloat(p.Names);
ShaderPropertyFloat f = p.GetValue <ShaderPropertyFloat>(new ShaderPropertyFloat());
Assert.AreEqual(f.Value, originValue);
}
break;
case ShaderPropertyType.Color:
{
Assert.AreEqual(p.ValueType, ShaderPropertyValue.ShaderPropertyColor);
UnityEngine.Color originValue = realMaterial.GetColor(p.Names);
ShaderPropertyColor c = p.GetValue <ShaderPropertyColor>(new ShaderPropertyColor());
Assert.AreEqual(originValue.a, c.Color.A);
Assert.AreEqual(originValue.g, c.Color.G);
Assert.AreEqual(originValue.b, c.Color.B);
Assert.AreEqual(originValue.r, c.Color.R);
}
break;
case ShaderPropertyType.Vector:
{
Assert.AreEqual(p.ValueType, ShaderPropertyValue.ShaderPropertyVector);
UnityEngine.Vector4 originValue = realMaterial.GetVector(p.Names);
ShaderPropertyVector v = p.GetValue <ShaderPropertyVector>(new ShaderPropertyVector());
Assert.AreEqual(originValue.x, v.Vector.X);
Assert.AreEqual(originValue.y, v.Vector.Y);
Assert.AreEqual(originValue.z, v.Vector.Z);
Assert.AreEqual(originValue.w, v.Vector.W);
}
break;
case ShaderPropertyType.TexEnv:
{
Assert.AreEqual(p.ValueType, ShaderPropertyValue.ShaderPropertyTexture);
//UnityEngine.Texture texture = realMaterial.GetTexture(p.Names);
Vector2 offset = realMaterial.GetTextureOffset(p.Names);
Vector2 scale = realMaterial.GetTextureScale(p.Names);
//这个测试用例不真正装载 texture.
//Assert.IsFalse(texture == null);
ShaderPropertyTexture t = p.GetValue <ShaderPropertyTexture>(new ShaderPropertyTexture());
string texturePath = resultMaterial.GetTexturePath(t.Name);
Assert.IsTrue(realMaterial.HasProperty(p.Names));
Assert.IsTrue(dictTextures.ContainsKey(texturePath));
Assert.IsNotNull(realMaterial.GetTexture(p.Names));
Assert.AreEqual(dictTextures[texturePath].resourceObject.Unity3dObject.GetInstanceID(), realMaterial.GetTexture(p.Names).GetInstanceID());
Assert.AreEqual(offset.x, t.Offset.X);
Assert.AreEqual(offset.y, t.Offset.Y);
Assert.AreEqual(scale.x, t.Scale.X);
Assert.AreEqual(scale.y, t.Scale.Y);
}
break;
}
}
}
private static Texture2D BuildPreviewTexture(int width, int height, Sprite sprite, Material spriteRendererMaterial)
{
if (!ShaderUtil.hardwareSupportsRectRenderTexture)
{
return null;
}
float width2 = sprite.rect.width;
float height2 = sprite.rect.height;
Texture2D spriteTexture = UnityEditor.Sprites.SpriteUtility.GetSpriteTexture(sprite, false);
PreviewHelpers.AdjustWidthAndHeightForStaticPreview((int)width2, (int)height2, ref width, ref height);
EditorUtility.SetTemporarilyAllowIndieRenderTexture(true);
SavedRenderTargetState savedRenderTargetState = new SavedRenderTargetState();
RenderTexture temporary = RenderTexture.GetTemporary(width, height, 0, RenderTextureFormat.Default, RenderTextureReadWrite.Default);
RenderTexture.active = temporary;
GL.sRGBWrite = (QualitySettings.activeColorSpace == ColorSpace.Linear);
GL.Clear(true, true, new Color(0f, 0f, 0f, 0f));
Texture texture = null;
Vector4 vector = new Vector4(0f, 0f, 0f, 0f);
bool flag = false;
bool flag2 = false;
if (spriteRendererMaterial != null)
{
flag = spriteRendererMaterial.HasProperty("_MainTex");
flag2 = spriteRendererMaterial.HasProperty("_MainTex_TexelSize");
}
Material material = null;
if (spriteRendererMaterial != null)
{
if (flag)
{
texture = spriteRendererMaterial.GetTexture("_MainTex");
spriteRendererMaterial.SetTexture("_MainTex", spriteTexture);
}
if (flag2)
{
vector = spriteRendererMaterial.GetVector("_MainTex_TexelSize");
spriteRendererMaterial.SetVector("_MainTex_TexelSize", TextureUtil.GetTexelSizeVector(spriteTexture));
}
spriteRendererMaterial.SetPass(0);
}
else
{
material = new Material(Shader.Find("Hidden/BlitCopy"));
material.mainTexture = spriteTexture;
material.SetPass(0);
}
float num = sprite.rect.width / sprite.bounds.size.x;
Vector2[] vertices = sprite.vertices;
Vector2[] uv = sprite.uv;
ushort[] triangles = sprite.triangles;
Vector2 pivot = sprite.pivot;
GL.PushMatrix();
GL.LoadOrtho();
GL.Color(new Color(1f, 1f, 1f, 1f));
GL.Begin(4);
for (int i = 0; i < sprite.triangles.Length; i++)
{
ushort num2 = triangles[i];
Vector2 vector2 = vertices[(int)num2];
Vector2 vector3 = uv[(int)num2];
GL.TexCoord(new Vector3(vector3.x, vector3.y, 0f));
GL.Vertex3((vector2.x * num + pivot.x) / width2, (vector2.y * num + pivot.y) / height2, 0f);
}
GL.End();
GL.PopMatrix();
GL.sRGBWrite = false;
if (spriteRendererMaterial != null)
{
if (flag)
{
spriteRendererMaterial.SetTexture("_MainTex", texture);
}
if (flag2)
{
spriteRendererMaterial.SetVector("_MainTex_TexelSize", vector);
}
}
Texture2D texture2D = new Texture2D(width, height, TextureFormat.ARGB32, false);
texture2D.hideFlags = HideFlags.HideAndDontSave;
texture2D.ReadPixels(new Rect(0f, 0f, (float)width, (float)height), 0, 0);
texture2D.Apply();
RenderTexture.ReleaseTemporary(temporary);
savedRenderTargetState.Restore();
EditorUtility.SetTemporarilyAllowIndieRenderTexture(false);
if (material != null)
{
UnityEngine.Object.DestroyImmediate(material);
}
return texture2D;
}
public void EqualSource()
{
Assert.AreEqual(material.Name, originMaterial.name);
Assert.AreEqual(material.Shader, originMaterial.shader.name);
for (int i = 0; i < material.PropertiesLength; i++)
{
Schema.ShaderProperty p = material.GetProperties(i);
Assert.IsTrue(originMaterial.HasProperty(p.Names));
switch (p.Type)
{
case ShaderPropertyType.Float:
case ShaderPropertyType.Range:
{
Assert.AreEqual(p.ValueType, ShaderPropertyValue.ShaderPropertyFloat);
float originValue = originMaterial.GetFloat(p.Names);
ShaderPropertyFloat f = p.GetValue <ShaderPropertyFloat>(new ShaderPropertyFloat());
Assert.AreEqual(f.Value, originValue);
}
break;
case ShaderPropertyType.Color:
{
Assert.AreEqual(p.ValueType, ShaderPropertyValue.ShaderPropertyColor);
UnityEngine.Color originValue = originMaterial.GetColor(p.Names);
ShaderPropertyColor c = p.GetValue <ShaderPropertyColor>(new ShaderPropertyColor());
Assert.AreEqual(originValue.a, c.Color.A);
Assert.AreEqual(originValue.g, c.Color.G);
Assert.AreEqual(originValue.b, c.Color.B);
Assert.AreEqual(originValue.r, c.Color.R);
}
break;
case ShaderPropertyType.Vector:
{
Assert.AreEqual(p.ValueType, ShaderPropertyValue.ShaderPropertyVector);
UnityEngine.Vector4 originValue = originMaterial.GetVector(p.Names);
ShaderPropertyVector v = p.GetValue <ShaderPropertyVector>(new ShaderPropertyVector());
Assert.AreEqual(originValue.x, v.Vector.X);
Assert.AreEqual(originValue.y, v.Vector.Y);
Assert.AreEqual(originValue.z, v.Vector.Z);
Assert.AreEqual(originValue.w, v.Vector.W);
}
break;
case ShaderPropertyType.TexEnv:
{
Assert.AreEqual(p.ValueType, ShaderPropertyValue.ShaderPropertyTexture);
UnityEngine.Texture texture = originMaterial.GetTexture(p.Names);
Vector2 offset = originMaterial.GetTextureOffset(p.Names);
Vector2 scale = originMaterial.GetTextureScale(p.Names);
Assert.IsFalse(texture == null);
ShaderPropertyTexture t = p.GetValue <ShaderPropertyTexture>(new ShaderPropertyTexture());
Assert.AreEqual(texture.name, t.Name);
Assert.AreEqual(offset.x, t.Offset.X);
Assert.AreEqual(offset.y, t.Offset.Y);
Assert.AreEqual(scale.x, t.Scale.X);
Assert.AreEqual(scale.y, t.Scale.Y);
}
break;
}
}
}
private static GLTF.Schema.Material ConvertSeinCustomMaterial(UnityEngine.Material mat, ExporterEntry entry)
{
if (_tempGO == null)
{
_tempGO = new GameObject();
}
var customMaterial = _tempGO.AddComponent <SeinCustomMaterial>();
var className = mat.shader.name.Replace("Sein/", "");
if (!className.Contains("Material"))
{
className += "Material";
}
customMaterial.className = className;
customMaterial.renderOrder = mat.renderQueue;
var floatArray = new List <SeinMaterialUniformFloat>();
var vector4Array = new List <SeinMaterialUniformFloatVec4>();
var textureArray = new List <SeinMaterialUniformTexture>();
for (int i = 0; i < ShaderUtil.GetPropertyCount(mat.shader); i += 1)
{
var propType = ShaderUtil.GetPropertyType(mat.shader, i);
var propName = ShaderUtil.GetPropertyName(mat.shader, i);
if (propName == "cloneForInst")
{
customMaterial.cloneForInst = mat.GetInt("cloneForInst") != 0;
continue;
}
if (ShaderUtil.IsShaderPropertyHidden(mat.shader, i))
{
continue;
}
var n = propName;
//if (propName.Substring(0, 1) == "_")
//{
// propName = propName.Substring(1);
//}
switch (propType)
{
case ShaderUtil.ShaderPropertyType.Float:
case ShaderUtil.ShaderPropertyType.Range:
floatArray.Add(new SeinMaterialUniformFloat {
name = propName, value = mat.GetFloat(n)
});
break;
case ShaderUtil.ShaderPropertyType.Color:
vector4Array.Add(new SeinMaterialUniformFloatVec4 {
name = propName, value = mat.GetColor(n)
});
break;
case ShaderUtil.ShaderPropertyType.Vector:
vector4Array.Add(new SeinMaterialUniformFloatVec4 {
name = propName, value = mat.GetVector(n)
});
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
if (mat.GetTexture(n) != null)
{
textureArray.Add(new SeinMaterialUniformTexture {
name = propName, value = (Texture2D)mat.GetTexture(n)
});
}
break;
}
customMaterial.uniformsFloat = floatArray.ToArray();
customMaterial.uniformsFloatVec4 = vector4Array.ToArray();
customMaterial.uniformsTexture = textureArray.ToArray();
}
var tempM = new GLTF.Schema.Material();
customMaterial.transparent = ProcessTransparency(mat, tempM);
var m = ConvertMaterial(customMaterial, entry);
return(m);
}
public static Texture2D BuildPreviewTexture(int width, int height, Sprite sprite, Material spriteRendererMaterial, bool isPolygon)
{
if (!ShaderUtil.hardwareSupportsRectRenderTexture)
return (Texture2D) null;
float width1 = sprite.rect.width;
float height1 = sprite.rect.height;
Texture2D spriteTexture = UnityEditor.Sprites.SpriteUtility.GetSpriteTexture(sprite, false);
if (!isPolygon)
PreviewHelpers.AdjustWidthAndHeightForStaticPreview((int) width1, (int) height1, ref width, ref height);
SavedRenderTargetState renderTargetState = new SavedRenderTargetState();
RenderTexture temporary = RenderTexture.GetTemporary(width, height, 0, RenderTextureFormat.Default, RenderTextureReadWrite.Default);
RenderTexture.active = temporary;
GL.sRGBWrite = QualitySettings.activeColorSpace == ColorSpace.Linear;
GL.Clear(true, true, new Color(0.0f, 0.0f, 0.0f, 0.0f));
Texture texture = (Texture) null;
Vector4 vector = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
bool flag1 = false;
bool flag2 = false;
if ((Object) spriteRendererMaterial != (Object) null)
{
flag1 = spriteRendererMaterial.HasProperty("_MainTex");
flag2 = spriteRendererMaterial.HasProperty("_MainTex_TexelSize");
}
Material material = (Material) null;
if ((Object) spriteRendererMaterial != (Object) null)
{
if (flag1)
{
texture = spriteRendererMaterial.GetTexture("_MainTex");
spriteRendererMaterial.SetTexture("_MainTex", (Texture) spriteTexture);
}
if (flag2)
{
vector = spriteRendererMaterial.GetVector("_MainTex_TexelSize");
spriteRendererMaterial.SetVector("_MainTex_TexelSize", TextureUtil.GetTexelSizeVector((Texture) spriteTexture));
}
spriteRendererMaterial.SetPass(0);
}
else
{
material = new Material(Shader.Find("Hidden/BlitCopy"));
material.mainTexture = (Texture) spriteTexture;
material.mainTextureScale = Vector2.one;
material.mainTextureOffset = Vector2.zero;
material.SetPass(0);
}
float num1 = sprite.rect.width / sprite.bounds.size.x;
Vector2[] vertices = sprite.vertices;
Vector2[] uv = sprite.uv;
ushort[] triangles = sprite.triangles;
Vector2 pivot = sprite.pivot;
GL.PushMatrix();
GL.LoadOrtho();
GL.Color(new Color(1f, 1f, 1f, 1f));
GL.Begin(4);
for (int index = 0; index < triangles.Length; ++index)
{
ushort num2 = triangles[index];
Vector2 vector2_1 = vertices[(int) num2];
Vector2 vector2_2 = uv[(int) num2];
GL.TexCoord(new Vector3(vector2_2.x, vector2_2.y, 0.0f));
GL.Vertex3((vector2_1.x * num1 + pivot.x) / width1, (vector2_1.y * num1 + pivot.y) / height1, 0.0f);
}
GL.End();
GL.PopMatrix();
GL.sRGBWrite = false;
if ((Object) spriteRendererMaterial != (Object) null)
{
if (flag1)
spriteRendererMaterial.SetTexture("_MainTex", texture);
if (flag2)
spriteRendererMaterial.SetVector("_MainTex_TexelSize", vector);
}
Texture2D texture2D = new Texture2D(width, height, TextureFormat.ARGB32, false);
texture2D.hideFlags = HideFlags.HideAndDontSave;
texture2D.ReadPixels(new Rect(0.0f, 0.0f, (float) width, (float) height), 0, 0);
texture2D.Apply();
RenderTexture.ReleaseTemporary(temporary);
renderTargetState.Restore();
if ((Object) material != (Object) null)
Object.DestroyImmediate((Object) material);
return texture2D;
}
private static KSerializeMaterialProperty _GetShaderVectorProp(Material mm, string texProp)
{
if (mm.HasProperty(texProp))
{
KSerializeMaterialProperty shaderProp = new KSerializeMaterialProperty();
shaderProp.Type = KSerializeMaterialProperty.ShaderType.Vector;
shaderProp.PropName = texProp;
Vector4 tex = mm.GetVector(texProp);
shaderProp.PropValue = tex.ToString();
return shaderProp;
}
return null;
}
public static Vector4 GetMaterialVector(System.String name, Material mat)
{
return mat.GetVector(name);
}
public Uniform(Material material, string uniform, string type)
{
Type = type;
Name = uniform;
if (Type.Equals("float")) {
float f = material.GetFloat(Name);
Value = f.ToString(GLexConfig.HighPrecision);
}
else if (Type.Equals("color") || Type.Equals("vector3")) {
Color color = material.GetColor(Name);
Value = "[ " + color.r.ToString(GLexConfig.MediumPrecision) + ", " + color.g.ToString(GLexConfig.MediumPrecision) + ", " + color.b.ToString(GLexConfig.MediumPrecision) + " ]";
}
else if (Type.Equals("color32") || Type.Equals("vector4")) {
Vector4 color32 = material.GetVector(Name);
Value = "[ " + color32.x.ToString(GLexConfig.MediumPrecision) + ", " + color32.y.ToString(GLexConfig.MediumPrecision) + ", " + color32.z.ToString(GLexConfig.MediumPrecision) + ", " + color32.z.ToString(GLexConfig.MediumPrecision) + " ]";
}
}
public List<MaterialProperty> GetShaderProperties(Material material)
{
if(cache.ContainsKey(material.shader.name))
return cache[material.shader.name];
var list = new List<MaterialProperty>();
foreach(var m in MaterialProperties)
{
if(material.HasProperty(m.name))
{
if(m.type == MaterialProperty.PropertyType.unknown)
{
try
{
var p = material.GetColor(m.name);
if(p != transparent)
list.Add( new MaterialProperty { name = m.name, type = MaterialProperty.PropertyType.color });
}
catch
{
}
try
{
var p = material.GetFloat(m.name);
if(p != 0)
list.Add( new MaterialProperty { name = m.name, type = MaterialProperty.PropertyType.real });
}
catch
{
}
try
{
var p = material.GetTexture(m.name);
if(p!=null)
list.Add( new MaterialProperty { name = m.name, type = MaterialProperty.PropertyType.texture });
}
catch
{
}
try
{
var p = material.GetVector(m.name);
if(p != Vector4.zero)
list.Add( new MaterialProperty { name = m.name, type = MaterialProperty.PropertyType.vector });
}
catch
{
}
try
{
var p = material.GetMatrix(m.name);
if(p != Matrix4x4.identity)
list.Add( new MaterialProperty { name = m.name, type = MaterialProperty.PropertyType.matrix });
}
catch
{
}
try
{
var p = material.GetTextureOffset(m.name);
if(p != Vector2.zero)
list.Add( new MaterialProperty { name = m.name, type = MaterialProperty.PropertyType.textureOffset });
}
catch
{
}
try
{
var p = material.GetTextureScale(m.name);
if(p != Vector2.zero)
list.Add( new MaterialProperty { name = m.name, type = MaterialProperty.PropertyType.textureScale });
}
catch
{
}
}
else
{
list.Add(m);
}
}
}
cache[material.shader.name] = list;
return list;
}
void CopyVector(string propName, string targetPropName, Material sourceMaterial, Material targetMaterial) {
if (sourceMaterial.HasProperty(propName) && targetMaterial.HasProperty(targetPropName)) {
targetMaterial.SetVector(targetPropName, sourceMaterial.GetVector(propName));
}
}
