private static bool ProcessTransparency(UnityEngine.Material mat, GLTF.Schema.Material material)
{
if (!mat.HasProperty("_Mode"))
{
return(false);
}
switch ((int)mat.GetFloat("_Mode"))
{
// Opaque
case 0:
material.AlphaMode = AlphaMode.OPAQUE;
return(false);
// Cutout
case 1:
material.AlphaMode = AlphaMode.MASK;
material.AlphaCutoff = mat.GetFloat("_Cutoff");
break;
// Transparent
case 2:
case 3:
material.AlphaMode = AlphaMode.BLEND;
break;
}
return(true);
}
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_beginFloat = m_Material.GetFloat(m_property);
}
else if (m_propertyID != -1)
{
m_beginFloat = m_Material.GetFloat(m_propertyID);
} // end if
}
bool checkSpecUsage(Material mat, string label) {
if ((label.IndexOf("layer Spec+Gloss")<0) && (label.IndexOf("gloss mask")<0) && (label.IndexOf("Spec (RGB)")<0)) return true;
if (!mat.HasProperty("_DirectSpec")) return true;
if (!mat.HasProperty("_IBLSpec")) return true;
if (mat.GetFloat("_DirectSpec")==0 && mat.GetFloat("_IBLSpec")==0) return false;
return true;
}
void Update()
{
terrain = GetComponent<Terrain>();
tData = terrain ? terrain.terrainData : null;
tMaterial = terrain ? terrain.materialTemplate : null;
if (!terrain || !tData || !tMaterial)
return;
if(disableBasemap && !Application.isPlaying && GetComponent<Terrain>().basemapDistance != 1000000) // only reset on update in edit mode
GetComponent<Terrain>().basemapDistance = 1000000;
if (cutoutMode)
{
if (tMaterial.HasProperty("_CutoutModeHideAlpha") && tMaterial.GetFloat("_CutoutModeHideAlpha") != cutoutModeHideAlpha)
tMaterial.SetFloat("_CutoutModeHideAlpha", cutoutModeHideAlpha);
}
else
if (tMaterial.HasProperty("_CutoutModeHideAlpha") && tMaterial.GetFloat("_CutoutModeHideAlpha") != -1)
tMaterial.SetFloat("_CutoutModeHideAlpha", -1);
if (!Application.isPlaying)
ApplyTransparencyMap();
else
if (!transparencyMap && autoUpdateTransparencyMap)
{
UpdateTransparencyMap();
ApplyTransparencyMap();
}
else
ApplyTransparencyMap();
}
/// <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;
}
}
}
}
// Use this for initialization
void Start () {
heatMaterial = heat.renderer.material;
defaultStrength = heatMaterial.GetFloat("strength");
strength = defaultStrength;
defaultTransparency = heatMaterial.GetFloat("transparency");
transparency = defaultTransparency;
}
private PbrMetallicRoughness ExportPBRMetallicRoughness(UnityEngine.Material material)
{
var pbr = new PbrMetallicRoughness();
if (material.HasProperty("_Color"))
{
pbr.BaseColorFactor = material.GetColor("_Color").ToNumericsColorRaw();
}
if (material.HasProperty("_MainTex"))
{
var mainTex = material.GetTexture("_MainTex");
if (mainTex != null)
{
pbr.BaseColorTexture = ExportTextureInfo(mainTex);
ExportTextureTransform(pbr.BaseColorTexture, material, "_MainTex");
}
}
if (material.HasProperty("_Metallic"))
{
pbr.MetallicFactor = material.GetFloat("_Metallic");
}
if (material.HasProperty("_Roughness"))
{
pbr.RoughnessFactor = material.GetFloat("_Roughness");
}
else if (material.HasProperty("_Glossiness"))
{
pbr.RoughnessFactor = 1 - material.GetFloat("_Glossiness");
}
if (material.HasProperty("_MetallicRoughnessMap"))
{
var mrTex = material.GetTexture("_MetallicRoughnessMap");
if (mrTex != null)
{
pbr.MetallicRoughnessTexture = ExportTextureInfo(mrTex);
ExportTextureTransform(pbr.MetallicRoughnessTexture, material, "_MetallicRoughnessMap");
}
}
else if (material.HasProperty("_MetallicGlossMap"))
{
var mgTex = material.GetTexture("_MetallicGlossMap");
if (mgTex != null)
{
pbr.MetallicRoughnessTexture = ExportTextureInfo(mgTex);
ExportTextureTransform(pbr.MetallicRoughnessTexture, material, "_MetallicGlossMap");
}
}
return(pbr);
}
// Function to calculate padding required for Outline Width & Dilation for proper text alignment
public static Vector4 GetFontExtent(Material material)
{
if (!material.HasProperty(ShaderUtilities.ID_GradientScale))
return Vector4.zero; // We are using an non SDF Shader.
float scaleRatioA = material.GetFloat(ID_ScaleRatio_A);
float faceDilate = material.GetFloat(ID_FaceDilate) * scaleRatioA;
float outlineThickness = material.GetFloat(ID_OutlineWidth) * scaleRatioA;
float extent = Mathf.Min(1, faceDilate + outlineThickness);
extent *= material.GetFloat(ID_GradientScale);
return new Vector4(extent, extent, extent, extent);
}
public void SetToToCurrent()
{
if (_material = material)
{
to = _material.GetFloat(propertyID);
}
}
public void SetFromToCurrent()
{
if (_material = material)
{
from = _material.GetFloat(propertyID);
}
}
public override void OnRecord()
{
if (_material = material)
{
_original = _material.GetFloat(propertyID);
}
}
static NormalTextureInfo ExportNormalTextureInfo(
UnityEngine.Texture texture,
TextureMapType textureMapType,
UnityEngine.Material material,
IGltfWritable gltf
)
{
var imageId = gltf.AddImage(texture);
if (imageId < 0)
{
return(null);
}
var textureId = gltf.AddTexture(imageId);
var info = new NormalTextureInfo {
index = textureId,
// texCoord = 0 // TODO: figure out which UV set was used
};
if (material.HasProperty(MaterialGenerator.bumpScalePropId))
{
info.scale = material.GetFloat(MaterialGenerator.bumpScalePropId);
}
return(info);
}
static public int GetFloat(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.GetFloat(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.GetFloat(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));
}
}
/// <summary>
/// Export a normal texture from Unity to glTF.
/// </summary>
/// <param name="texture">Normal texture to export</param>
/// <param name="material">Material the normal is used on</param>
/// <param name="gltf">Context glTF to export to</param>
/// <returns>glTF texture info</returns>
protected static NormalTextureInfo ExportNormalTextureInfo(
UnityEngine.Texture texture,
UnityEngine.Material material,
IGltfWritable gltf
)
{
var texture2d = texture as Texture2D;
if (texture2d == null)
{
return(null);
}
var imageExport = new NormalImageExport(texture2d);
if (AddImageExport(gltf, imageExport, out var textureId))
{
var info = new NormalTextureInfo {
index = textureId,
// texCoord = 0 // TODO: figure out which UV set was used
};
if (material.HasProperty(MaterialGenerator.bumpScalePropId))
{
info.scale = material.GetFloat(MaterialGenerator.bumpScalePropId);
}
return(info);
}
return(null);
}
protected StandardMap(Material mat, int MaxLOD = 1000)
{
mat.shader.maximumLOD = MaxLOD;
_material = mat;
if (mat.HasProperty(_Cutoff))
{
_alphaCutoff = mat.GetFloat(_Cutoff);
}
switch (mat.renderQueue)
{
case (int)RenderQueue.AlphaTest:
_alphaMode = AlphaMode.MASK;
break;
case (int)RenderQueue.Transparent:
_alphaMode = AlphaMode.BLEND;
break;
case (int)RenderQueue.Geometry:
default:
_alphaMode = AlphaMode.OPAQUE;
break;
}
}
public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
{
if (material.HasProperty("_Emission"))
{
material.SetColor("_EmissionColor", material.GetColor("_Emission"));
}
base.AssignNewShaderToMaterial(material, oldShader, newShader);
if ((oldShader == null) || !oldShader.name.Contains("Legacy Shaders/"))
{
SetupMaterialWithBlendMode(material, (BlendMode) ((int) material.GetFloat("_Mode")));
}
else
{
BlendMode opaque = BlendMode.Opaque;
if (oldShader.name.Contains("/Transparent/Cutout/"))
{
opaque = BlendMode.Cutout;
}
else if (oldShader.name.Contains("/Transparent/"))
{
opaque = BlendMode.Fade;
}
material.SetFloat("_Mode", (float) opaque);
Material[] mats = new Material[] { material };
this.DetermineWorkflow(MaterialEditor.GetMaterialProperties(mats));
MaterialChanged(material, this.m_WorkflowMode);
}
}
void Awake()
{
// make a private material
animatedMaterial = Object.Instantiate(Helpers.LoadResource<Material>("TrillingFastPoint")) as Material;
animatedMaterial.name = animatedMaterial.name.Replace("(Clone)", "");
tunnelDDef = animatedMaterial.GetFloat("_TunnelD");
tunnelDWarp = animatedMaterial.GetFloat("_TunnelDMax");
tunnelRDef = animatedMaterial.GetFloat("_TunnelRadius");
tunnelRWarp = animatedMaterial.GetFloat("_TunnelRadiusMax");
if (renderer != null)
renderer.sharedMaterial = animatedMaterial;
foreach(MeshRenderer mr in GetComponentsInChildren<MeshRenderer>()) {
mr.sharedMaterial = animatedMaterial;
}
}
static public int GetFloat(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);
System.Single ret = self.GetFloat(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);
System.Single ret = self.GetFloat(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 int GetFloat(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);
float o = obj.GetFloat(arg0);
LuaDLL.lua_pushnumber(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);
float o = obj.GetFloat(arg0);
LuaDLL.lua_pushnumber(L, o);
return(1);
}
else
{
return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.Material.GetFloat"));
}
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
void checkRenderingMode(Material mat)
{
if (mat.GetFloat ("_Mode") != 3)
{
Debug.LogError ("Make sure the fadable material has a rendering mode of Transparent");
}
}
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 static void SetMaterialKeywords(Material material, WorkflowMode workflowMode)
{
// 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"));
if (workflowMode == WorkflowMode.Specular && material.HasProperty("_SpecGlossMap"))
SetKeyword(material, "_SPECGLOSSMAP", material.GetTexture("_SpecGlossMap"));
else if (workflowMode == WorkflowMode.Metallic && material.HasProperty("_MetallicGlossMap"))
SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));
SetKeyword(material, "_PARALLAXMAP", material.GetTexture("_ParallaxMap"));
SetKeyword(material, "_DETAIL_MULX2", material.GetTexture("_DetailAlbedoMap") || material.GetTexture("_DetailNormalMap"));
bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled(material.GetColor("_EmissionColor"));
SetKeyword(material, "_EMISSION", shouldEmissionBeEnabled);
// 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;
}
SetKeyword(material, "_VERTEXCOLOR", material.GetFloat("_IntensityVC") > 0f);
}
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;
}
void Awake ()
{
material = GetComponent<Renderer>().material;
cubemap = (Cubemap)material.GetTexture("_Cube");
rendererArray = GetComponentsInChildren<Renderer>();
rotation = material.GetFloat("_Rotation");
bookArray = GetComponentsInChildren<Book>();
}
private void Awake()
{
Material m = new Material(renderer.material);
renderer.material = m;
originalShininess = m.GetFloat("_Shininess");
glow = transform.Find("crystal glow").gameObject;
glow.SetActive(false);
}
void Start()
{
if(gameObject.GetComponent<Renderer>().material)
{
meshMaterials = gameObject.GetComponent<Renderer>().material;
originalRimPower = meshMaterials.GetFloat ("_RimPower");
originalRimStrength = meshMaterials.GetFloat ("_RimStrength");
ShineRim();
Invoke ("ReturnToOriginalRim", timer);
}
else
{
this.enabled = false;
}
}
void Start()
{
lastParentPos = transform.parent.position;
maxDistance = transform.localPosition.z;
if (fadeLayer) {
origMaterial = fadeLayer.sharedMaterial;
oldScale = noiseScale = origMaterial.GetFloat("NoiseScale");
}
}
static JsonData getMetalData(UnityEngine.Material mat, Paladin paladin = null)
{
var ret = new JsonData();
ret["type"] = mat.name;
var param = new JsonData();
param["eta"] = Util.fromColor(mat.GetColor("_eta"));
param["k"] = Util.fromColor(mat.GetColor("k"));
param["uRough"] = mat.GetFloat("_uRoughness");
param["vRough"] = mat.GetFloat("_vRoughness");
param["rough"] = null;
bool remap = mat.GetInt("_remapRoughness") != 0;
param["remapRough"] = remap;
ret["param"] = param;
return(ret);
}
public MaterialProperty(Material material, string propertyName, float floatVal)
{
this.material = material;
this.propertyName = propertyName;
type = typeof (float);
if (material.HasProperty(propertyName)) {
value = material.GetFloat(propertyName);
material.SetFloat(propertyName, floatVal);
}
}
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 JsonData getGlassData(UnityEngine.Material mat, Paladin paladin = null)
{
var ret = new JsonData();
ret["type"] = mat.name;
var param = new JsonData();
param["Kr"] = Util.fromColor(mat.GetColor("_Kr"));
param["Kt"] = Util.fromColor(mat.GetColor("_Kt"));
param["uRough"] = mat.GetFloat("_uRoughness");
param["vRough"] = mat.GetFloat("_vRoughness");
param["eta"] = mat.GetFloat("_eta");
bool remap = mat.GetInt("_remapRoughness") != 0;
bool thin = mat.GetInt("_thin") != 0;
param["remapRough"] = remap;
param["thin"] = thin;
ret["param"] = param;
return(ret);
}
private NormalTextureInfo ExportNormalTextureInfo(UnityEngine.Texture texture, UnityEngine.Material material)
{
var info = new NormalTextureInfo();
info.Index = ExportTexture(texture);
if (material.HasProperty("_BumpScale"))
{
info.Scale = material.GetFloat("_BumpScale");
}
return(info);
}
private OcclusionTextureInfo ExportOcclusionTextureInfo(UnityEngine.Texture texture, UnityEngine.Material material)
{
var info = new OcclusionTextureInfo();
info.Index = ExportTexture(texture);
if (material.HasProperty("_OcclusionStrength"))
{
info.Strength = material.GetFloat("_OcclusionStrength");
}
return(info);
}
static JsonData getMatteData(UnityEngine.Material mat, Paladin paladin = null)
{
var ret = new JsonData();
ret["type"] = mat.name;
var param = new JsonData();
param["Kd"] = Util.fromColor(mat.GetColor("_Kd"));
param["sigma"] = mat.GetFloat("_sigma");
ret["param"] = param;
return(ret);
}
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);
}
}
}
}
public Sphere GetSphere()
{
var trans = transform;
var pos = trans.position;
var smoothness = m_UnityMaterial.GetFloat(Smoothness);
return(new Sphere
{
material =
{
albedo = m_UnityMaterial.GetAlbedo(),
fuzziness = (1f - smoothness),
type = m_MaterialType
},
radius = trans.localScale.x / 2,
center = pos,
});
}
// This is a hack for GI. PVR looks in the shader for a texture named "_MainTex" to extract the opacity of the material for baking. In the same manner, "_Cutoff" and "_Color" are also necessary.
// Since we don't have those parameters in our shaders we need to provide a "fake" useless version of them with the right values for the GI to work.
private static void SetupMainTexForAlphaTestGI(UnityEngine.Material unityMaterial, string colorMapPropertyName, string colorPropertyName)
{
if (unityMaterial.HasProperty(colorMapPropertyName))
{
var mainTex = unityMaterial.GetTexture(colorMapPropertyName);
unityMaterial.SetTexture(MainTex, mainTex);
}
if (unityMaterial.HasProperty(colorPropertyName))
{
var color = unityMaterial.GetColor(colorPropertyName);
unityMaterial.SetColor(Color, color);
}
if (unityMaterial.HasProperty("_AlphaCutoff"))
{
var cutoff = unityMaterial.GetFloat(AlphaCutoff);
unityMaterial.SetFloat(Cutoff, cutoff);
}
}
// Scale Ratios to ensure property ranges are optimum in Material Editor
public static void UpdateShaderRatios(Material mat, bool isBold)
{
float ratio_A = 1;
float ratio_B = 1;
float ratio_C = 1;
bool isRatioEnabled = !mat.shaderKeywords.Contains(Keyword_Ratios);
// Compute Ratio A
float scale = mat.GetFloat(ID_GradientScale);
float faceDilate = mat.GetFloat(ID_FaceDilate);
float outlineThickness = mat.GetFloat(ID_OutlineWidth);
float outlineSoftness = mat.GetFloat(ID_OutlineSoftness);
float weight = !isBold ? mat.GetFloat(ID_WeightNormal) * 2 / scale : mat.GetFloat(ID_WeightBold) * 2 / scale;
float t = Mathf.Max(1, weight + faceDilate + outlineThickness + outlineSoftness);
ratio_A = isRatioEnabled ? (scale - m_clamp) / (scale * t) : 1;
mat.SetFloat(ID_ScaleRatio_A, ratio_A);
// Compute Ratio B
if (mat.HasProperty(ID_GlowOffset))
{
float glowOffset = mat.GetFloat(ID_GlowOffset);
float glowOuter = mat.GetFloat(ID_GlowOuter);
float range = (weight + faceDilate) * (scale - m_clamp);
t = Mathf.Max(1, glowOffset + glowOuter);
ratio_B = isRatioEnabled ? Mathf.Max(0, scale - m_clamp - range) / (scale * t) : 1;
mat.SetFloat(ID_ScaleRatio_B, ratio_B);
}
// Compute Ratio C
if (mat.HasProperty(ID_UnderlayOffsetX))
{
float underlayOffsetX = mat.GetFloat(ID_UnderlayOffsetX);
float underlayOffsetY = mat.GetFloat(ID_UnderlayOffsetY);
float underlayDilate = mat.GetFloat(ID_UnderlayDilate);
float underlaySoftness = mat.GetFloat(ID_UnderlaySoftness);
float range = (weight + faceDilate) * (scale - m_clamp);
t = Mathf.Max(1, Mathf.Max(Mathf.Abs(underlayOffsetX), Mathf.Abs(underlayOffsetY)) + underlayDilate + underlaySoftness);
ratio_C = isRatioEnabled ? Mathf.Max(0, scale - m_clamp - range) / (scale * t) : 1;
mat.SetFloat(ID_ScaleRatio_C, ratio_C);
}
}
/// <summary>
/// Applies alpha mode and cutoff
/// </summary>
/// <param name="uMaterial">Source Unity Material</param>
/// <param name="material">glTF material to apply settings on</param>
protected static void SetAlphaModeAndCutoff(UnityEngine.Material uMaterial, Material material)
{
switch (uMaterial.GetTag("RenderType", false, ""))
{
case "TransparentCutout":
if (uMaterial.HasProperty(k_Cutoff))
{
material.alphaCutoff = uMaterial.GetFloat(k_Cutoff);
}
material.alphaModeEnum = Material.AlphaMode.MASK;
break;
case "Transparent":
case "Fade":
material.alphaModeEnum = Material.AlphaMode.BLEND;
break;
default:
material.alphaModeEnum = Material.AlphaMode.OPAQUE;
break;
}
}
static VrmLib.PBRMaterial ExportStandard(UnityEngine.Material src, GetOrCreateTextureDelegate map)
{
var material = new VrmLib.PBRMaterial(src.name)
{
};
switch (src.GetTag("RenderType", true))
{
case "Transparent":
material.AlphaMode = VrmLib.AlphaModeType.BLEND;
break;
case "TransparentCutout":
material.AlphaMode = VrmLib.AlphaModeType.MASK;
material.AlphaCutoff = src.GetFloat("_Cutoff");
break;
default:
material.AlphaMode = VrmLib.AlphaModeType.OPAQUE;
break;
}
if (src.HasProperty("_Color"))
{
material.BaseColorFactor = src.color.linear.FromUnitySrgbToLinear();
}
if (src.HasProperty("_MainTex"))
{
material.BaseColorTexture = map(src, src.GetTexture("_MainTex"), VrmLib.Texture.ColorSpaceTypes.Srgb, VrmLib.Texture.TextureTypes.Default);
}
if (src.HasProperty("_MetallicGlossMap"))
{
// float smoothness = 0.0f;
// if (m.HasProperty("_GlossMapScale"))
// {
// smoothness = m.GetFloat("_GlossMapScale");
// }
material.MetallicRoughnessTexture = map(
src,
src.GetTexture("_MetallicGlossMap"),
VrmLib.Texture.ColorSpaceTypes.Linear,
VrmLib.Texture.TextureTypes.MetallicRoughness)?.Texture;
if (material.MetallicRoughnessTexture != null)
{
material.MetallicFactor = 1.0f;
// Set 1.0f as hard-coded. See: https://github.com/vrm-c/UniVRM/issues/212.
material.RoughnessFactor = 1.0f;
}
}
if (material.MetallicRoughnessTexture == null)
{
if (src.HasProperty("_Metallic"))
{
material.MetallicFactor = src.GetFloat("_Metallic");
}
if (src.HasProperty("_Glossiness"))
{
material.RoughnessFactor = 1.0f - src.GetFloat("_Glossiness");
}
}
if (src.HasProperty("_BumpMap"))
{
material.NormalTexture = map(src, src.GetTexture("_BumpMap"), VrmLib.Texture.ColorSpaceTypes.Linear, VrmLib.Texture.TextureTypes.NormalMap)?.Texture;
if (src.HasProperty("_BumpScale"))
{
material.NormalTextureScale = src.GetFloat("_BumpScale");
}
}
if (src.HasProperty("_OcclusionMap"))
{
material.OcclusionTexture = map(src, src.GetTexture("_OcclusionMap"), VrmLib.Texture.ColorSpaceTypes.Linear, VrmLib.Texture.TextureTypes.Occlusion)?.Texture;
if (src.HasProperty("_OcclusionStrength"))
{
material.OcclusionTextureStrength = src.GetFloat("_OcclusionStrength");
}
}
if (src.IsKeywordEnabled("_EMISSION"))
{
if (src.HasProperty("_EmissionColor"))
{
var color = src.GetColor("_EmissionColor");
if (color.maxColorComponent > 1)
{
color /= color.maxColorComponent;
}
material.EmissiveFactor = new System.Numerics.Vector3(color.r, color.g, color.b);
}
if (src.HasProperty("_EmissionMap"))
{
material.EmissiveTexture = map(src, src.GetTexture("_EmissionMap"), VrmLib.Texture.ColorSpaceTypes.Srgb, VrmLib.Texture.TextureTypes.Emissive)?.Texture;
}
}
return(material);
}
// helper functions to retrieve & set material values
public static float GetMaterialFloat(System.String name, Material mat)
{
return mat.GetFloat(name);
}
public VrmLib.TextureInfo GetOrCreateTexture(UnityEngine.Material material, UnityEngine.Texture srcTexture, VrmLib.Texture.ColorSpaceTypes colorSpace, VrmLib.Texture.TextureTypes textureType)
{
var texture = srcTexture as Texture2D;
if (texture is null)
{
return(null);
}
if (!Textures.TryGetValue(texture, out VrmLib.TextureInfo info))
{
UnityEngine.Material converter = null;
if (textureType == VrmLib.Texture.TextureTypes.NormalMap)
{
converter = TextureConvertMaterial.GetNormalMapConvertUnityToGltf();
}
else if (textureType == VrmLib.Texture.TextureTypes.MetallicRoughness)
{
float smoothness = 0.0f;
if (material.HasProperty("_GlossMapScale"))
{
smoothness = material.GetFloat("_GlossMapScale");
}
converter = TextureConvertMaterial.GetMetallicRoughnessUnityToGltf(smoothness);
}
else if (textureType == VrmLib.Texture.TextureTypes.Occlusion)
{
converter = TextureConvertMaterial.GetOcclusionUnityToGltf();
}
var(bytes, mime) = GetImageEncodedBytes(
texture,
(colorSpace == VrmLib.Texture.ColorSpaceTypes.Linear) ? RenderTextureReadWrite.Linear : RenderTextureReadWrite.sRGB,
converter
);
if (converter != null)
{
UnityEngine.Object.DestroyImmediate(converter);
}
var sampler = new VrmLib.TextureSampler
{
MagFilter = texture.filterMode.ToVrmLibMagFilter(),
MinFilter = texture.filterMode.ToVrmLibMinFilter(),
WrapS = texture.wrapMode.ToVrmLib(),
WrapT = texture.wrapMode.ToVrmLib(),
};
var image = new VrmLib.Image(texture.name, mime, VrmLib.ImageUsage.None, new ArraySegment <byte>(bytes));
info = new VrmLib.TextureInfo(new VrmLib.ImageTexture(texture.name, sampler, image, colorSpace, textureType));
Textures.Add(texture, info);
if (Model != null)
{
Model.Images.Add(image);
Model.Textures.Add(info.Texture);
}
}
return(info);
}
static bool ExportPbrMetallicRoughness(
UnityEngine.Material uMaterial,
Material material,
IGltfWritable gltf,
ICodeLogger logger
)
{
var success = true;
var pbr = new PbrMetallicRoughness {
metallicFactor = 0, roughnessFactor = 1.0f
};
MaskMapImageExport ormImageExport = null;
if (uMaterial.IsKeywordEnabled(k_KeywordMaskMap) && uMaterial.HasProperty(k_MaskMap))
{
var maskMap = uMaterial.GetTexture(k_MaskMap) as Texture2D;
if (maskMap != null)
{
ormImageExport = new MaskMapImageExport(maskMap);
if (AddImageExport(gltf, ormImageExport, out var ormTextureId))
{
// TODO: smartly detect if metallic roughness channels are used and not create the
// texture info if not.
pbr.metallicRoughnessTexture = new TextureInfo {
index = ormTextureId
};
ExportTextureTransform(pbr.metallicRoughnessTexture, uMaterial, k_MaskMap, gltf);
// TODO: smartly detect if occlusion channel is used and not create the
// texture info if not.
material.occlusionTexture = new OcclusionTextureInfo {
index = ormTextureId
};
if (uMaterial.HasProperty(k_AORemapMin))
{
var occMin = uMaterial.GetFloat(k_AORemapMin);
material.occlusionTexture.strength = math.clamp(1 - occMin, 0, 1);
var occMax = uMaterial.GetFloat(k_AORemapMax);
if (occMax < 1f)
{
// TODO: remap texture values
logger?.Warning(LogCode.RemapUnsupported, "AO");
}
}
}
}
}
if (uMaterial.HasProperty(k_BaseColor))
{
pbr.baseColor = uMaterial.GetColor(k_BaseColor);
}
else
if (uMaterial.HasProperty(k_Color))
{
pbr.baseColor = uMaterial.GetColor(k_Color);
}
if (uMaterial.HasProperty(k_BaseColorMap))
{
// TODO if additive particle, render black into alpha
// TODO use private Material.GetFirstPropertyNameIdByAttribute here, supported from 2020.1+
var mainTex = uMaterial.GetTexture(k_BaseColorMap);
if (mainTex)
{
if (mainTex is Texture2D)
{
pbr.baseColorTexture = ExportTextureInfo(mainTex, gltf);
ExportTextureTransform(pbr.baseColorTexture, uMaterial, k_BaseColorMap, gltf);
}
else
{
logger?.Error(LogCode.TextureInvalidType, "main", uMaterial.name);
success = false;
}
}
}
if (uMaterial.HasProperty(k_Metallic))
{
pbr.metallicFactor = uMaterial.GetFloat(k_Metallic);
}
if (ormImageExport != null && uMaterial.HasProperty(k_SmoothnessRemapMax))
{
pbr.roughnessFactor = uMaterial.GetFloat(k_SmoothnessRemapMax);
if (uMaterial.HasProperty(k_SmoothnessRemapMin) && uMaterial.GetFloat(k_SmoothnessRemapMin) > 0)
{
logger?.Warning(LogCode.RemapUnsupported, "Smoothness");
}
}
else
if (uMaterial.HasProperty(k_Smoothness))
{
pbr.roughnessFactor = 1f - uMaterial.GetFloat(k_Smoothness);
}
material.pbrMetallicRoughness = pbr;
return(success);
}
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);
}
private bool GUIMaterialSlider(Material material, string propertyID, string contentID)
{
bool flag = false;
this.GUIPropBegin();
float @float = material.GetFloat(propertyID);
float num2 = EditorGUILayout.Slider(TreeEditorHelper.GetGUIContent(contentID), @float, 0f, 1f, new GUILayoutOption[0]);
if (num2 != @float)
{
Undo.RegisterCompleteObjectUndo(material, "Material");
material.SetFloat(propertyID, num2);
flag = true;
}
this.GUIPropEnd();
return flag;
}
// Function to determine how much extra padding is required as a result of material properties like dilate, outline thickness, softness, glow, etc...
public static float GetPadding(Material material, bool enableExtraPadding, bool isBold)
{
//Debug.Log("GetPadding() called.");
if (isInitialized == false)
GetShaderPropertyIDs();
// Return if Material is null
if (material == null) return 0;
int extraPadding = enableExtraPadding ? 4 : 0;
if (!material.HasProperty(ID_GradientScale))
return extraPadding; // We are using an non SDF Shader.
Vector4 padding = Vector4.zero;
Vector4 maxPadding = Vector4.zero;
float faceDilate = 0;
float faceSoftness = 0;
float outlineThickness = 0;
float scaleRatio_A = 0;
float scaleRatio_B = 0;
float scaleRatio_C = 0;
float glowOffset = 0;
float glowOuter = 0;
float uniformPadding = 0;
// Iterate through each of the assigned materials to find the max values to set the padding.
// Update Shader Ratios prior to computing padding
UpdateShaderRatios(material, isBold);
string[] shaderKeywords = material.shaderKeywords;
if (material.HasProperty(ID_ScaleRatio_A))
scaleRatio_A = material.GetFloat(ID_ScaleRatio_A);
if (material.HasProperty(ID_FaceDilate))
faceDilate = material.GetFloat(ID_FaceDilate) * scaleRatio_A;
if (material.HasProperty(ID_OutlineSoftness))
faceSoftness = material.GetFloat(ID_OutlineSoftness) * scaleRatio_A;
if (material.HasProperty(ID_OutlineWidth))
outlineThickness = material.GetFloat(ID_OutlineWidth) * scaleRatio_A;
uniformPadding = outlineThickness + faceSoftness + faceDilate;
// Glow padding contribution
if (material.HasProperty(ID_GlowOffset) && shaderKeywords.Contains(Keyword_Glow)) // Generates GC
{
if (material.HasProperty(ID_ScaleRatio_B))
scaleRatio_B = material.GetFloat(ID_ScaleRatio_B);
glowOffset = material.GetFloat(ID_GlowOffset) * scaleRatio_B;
glowOuter = material.GetFloat(ID_GlowOuter) * scaleRatio_B;
}
uniformPadding = Mathf.Max(uniformPadding, faceDilate + glowOffset + glowOuter);
// Underlay padding contribution
if (material.HasProperty(ID_UnderlaySoftness) && shaderKeywords.Contains(Keyword_Underlay)) // Generates GC
{
if (material.HasProperty(ID_ScaleRatio_C))
scaleRatio_C = material.GetFloat(ID_ScaleRatio_C);
float offsetX = material.GetFloat(ID_UnderlayOffsetX) * scaleRatio_C;
float offsetY = material.GetFloat(ID_UnderlayOffsetY) * scaleRatio_C;
float dilate = material.GetFloat(ID_UnderlayDilate) * scaleRatio_C;
float softness = material.GetFloat(ID_UnderlaySoftness) * scaleRatio_C;
padding.x = Mathf.Max(padding.x, faceDilate + dilate + softness - offsetX);
padding.y = Mathf.Max(padding.y, faceDilate + dilate + softness - offsetY);
padding.z = Mathf.Max(padding.z, faceDilate + dilate + softness + offsetX);
padding.w = Mathf.Max(padding.w, faceDilate + dilate + softness + offsetY);
}
padding.x = Mathf.Max(padding.x, uniformPadding);
padding.y = Mathf.Max(padding.y, uniformPadding);
padding.z = Mathf.Max(padding.z, uniformPadding);
padding.w = Mathf.Max(padding.w, uniformPadding);
padding.x += extraPadding;
padding.y += extraPadding;
padding.z += extraPadding;
padding.w += extraPadding;
padding.x = Mathf.Min(padding.x, 1);
padding.y = Mathf.Min(padding.y, 1);
padding.z = Mathf.Min(padding.z, 1);
padding.w = Mathf.Min(padding.w, 1);
maxPadding.x = maxPadding.x < padding.x ? padding.x : maxPadding.x;
maxPadding.y = maxPadding.y < padding.y ? padding.y : maxPadding.y;
maxPadding.z = maxPadding.z < padding.z ? padding.z : maxPadding.z;
maxPadding.w = maxPadding.w < padding.w ? padding.w : maxPadding.w;
float gradientScale = material.GetFloat(ID_GradientScale);
padding *= gradientScale;
// Set UniformPadding to the maximum value of any of its components.
uniformPadding = Mathf.Max(padding.x, padding.y);
uniformPadding = Mathf.Max(padding.z, uniformPadding);
uniformPadding = Mathf.Max(padding.w, uniformPadding);
return uniformPadding + 0.5f;
}
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);
}
public VrmLib.Material Export10(UnityEngine.Material src, GetOrCreateTextureDelegate map)
{
switch (src.shader.name)
{
case "VRM/MToon":
{
var def = MToon.Utils.GetMToonParametersFromMaterial(src);
return(new VrmLib.MToonMaterial(src.name)
{
Definition = def.ToVrmLib(src, map),
});
}
case "Unlit/Color":
return(new VrmLib.UnlitMaterial(src.name)
{
BaseColorFactor = src.color.FromUnitySrgbToLinear(),
});
case "Unlit/Texture":
return(new VrmLib.UnlitMaterial(src.name)
{
BaseColorTexture = map(src, src.mainTexture as Texture2D, VrmLib.Texture.ColorSpaceTypes.Srgb, VrmLib.Texture.TextureTypes.Default),
});
case "Unlit/Transparent":
return(new VrmLib.UnlitMaterial(src.name)
{
BaseColorTexture = map(src, src.mainTexture as Texture2D, VrmLib.Texture.ColorSpaceTypes.Srgb, VrmLib.Texture.TextureTypes.Default),
AlphaMode = VrmLib.AlphaModeType.BLEND,
});
case "Unlit/Transparent Cutout":
return(new VrmLib.UnlitMaterial(src.name)
{
BaseColorTexture = map(src, src.mainTexture as Texture2D, VrmLib.Texture.ColorSpaceTypes.Srgb, VrmLib.Texture.TextureTypes.Default),
AlphaMode = VrmLib.AlphaModeType.MASK,
AlphaCutoff = src.GetFloat("_Cutoff"),
});
case "UniGLTF/UniUnlit":
case "VRM/UniUnlit":
{
var material = new VrmLib.UnlitMaterial(src.name)
{
BaseColorFactor = src.color.FromUnitySrgbToLinear(),
BaseColorTexture = map(src, src.mainTexture as Texture2D, VrmLib.Texture.ColorSpaceTypes.Srgb, VrmLib.Texture.TextureTypes.Default),
AlphaMode = GetAlphaMode(src),
DoubleSided = UniGLTF.UniUnlit.Utils.GetCullMode(src) == UniGLTF.UniUnlit.UniUnlitCullMode.Off,
};
if (material.AlphaMode == VrmLib.AlphaModeType.MASK)
{
material.AlphaCutoff = src.GetFloat("_Cutoff");
}
// TODO: VertexColorMode
return(material);
}
default:
return(ExportStandard(src, map));
}
}
private MaterialId ExportMaterial(UnityEngine.Material materialObj)
{
MaterialId id = GetMaterialId(_root, materialObj);
if (id != null)
{
return(id);
}
var material = new GLTF.Schema.Material();
if (ExportNames)
{
material.Name = materialObj.name;
}
if (materialObj.HasProperty("_Cutoff"))
{
material.AlphaCutoff = materialObj.GetFloat("_Cutoff");
}
switch (materialObj.GetTag("RenderType", false, ""))
{
case "TransparentCutout":
material.AlphaMode = AlphaMode.MASK;
break;
case "Transparent":
material.AlphaMode = AlphaMode.BLEND;
break;
default:
material.AlphaMode = AlphaMode.OPAQUE;
break;
}
material.DoubleSided = materialObj.HasProperty("_Cull") &&
materialObj.GetInt("_Cull") == (float)UnityEngine.Rendering.CullMode.Off;
if (materialObj.HasProperty("_EmissionColor"))
{
material.EmissiveFactor = materialObj.GetColor("_EmissionColor").ToNumericsColorRaw();
}
if (materialObj.HasProperty("_EmissionMap"))
{
var emissionTex = materialObj.GetTexture("_EmissionMap");
if (emissionTex != null)
{
material.EmissiveTexture = ExportTextureInfo(emissionTex);
ExportTextureTransform(material.EmissiveTexture, materialObj, "_EmissionMap");
}
}
if (materialObj.HasProperty("_BumpMap"))
{
var normalTex = materialObj.GetTexture("_BumpMap");
if (normalTex != null)
{
material.NormalTexture = ExportNormalTextureInfo(normalTex, materialObj);
ExportTextureTransform(material.NormalTexture, materialObj, "_BumpMap");
}
}
if (materialObj.HasProperty("_OcclusionMap"))
{
var occTex = materialObj.GetTexture("_OcclusionMap");
if (occTex != null)
{
material.OcclusionTexture = ExportOcclusionTextureInfo(occTex, materialObj);
ExportTextureTransform(material.OcclusionTexture, materialObj, "_OcclusionMap");
}
}
switch (materialObj.shader.name)
{
case "Standard":
case "GLTF/GLTFStandard":
material.PbrMetallicRoughness = ExportPBRMetallicRoughness(materialObj);
break;
case "GLTF/GLTFConstant":
material.CommonConstant = ExportCommonConstant(materialObj);
break;
}
_materials.Add(materialObj);
id = new MaterialId {
Id = _root.Materials.Count,
Root = _root
};
_root.Materials.Add(material);
return(id);
}
//Convert one Material from TCP1 to TCP2
static private void ConvertMaterial(Material m)
{
if(m == null)
return;
if(m.shader == null)
return;
string originalShader = m.shader.name;
if(originalShader.Contains("Toony Colors Pro 2"))
{
Debug.LogWarning("Skipping '" + m.name + "'\nMaterial already has TCP2 shader");
return;
}
else if(!originalShader.Contains("Toony Colors Pro/"))
{
Debug.LogWarning("Skipping '" + m.name + "'\nMaterial doesn't have TCP1 shader");
return;
}
// Keyword list
List<string> tcp2Keywords = new List<string>();
tcp2Keywords.Add("TCP2_RAMPTEXT"); //TCP1 only supports textured ramps
// Analyze shader name to determine its features
string[] nameParts = originalShader.Split(new string[]{"/"}, System.StringSplitOptions.RemoveEmptyEntries);
if(nameParts.Length != 4)
{
Debug.LogWarning("Skipping '" + m.name + "'\nIconrrect number of parts in the name");
return;
}
// 0 = Toony Colors Pro
// 1 = Normal, Outline, OutlineConst, Outline Z-Correct, OutlineConst Z-Correct, Rim Outline
// 2 = OneDirLight, MultipleLights
// 3 = Basic, Basic Rim, Bumped, Bumped Rim, Bumped Specular, Bumped Specular Rim, Specular, Specular Rim
switch(nameParts[1])
{
case "Normal": break;
case "Outline": tcp2Keywords.Add("OUTLINES"); break;
case "OutlineConst": tcp2Keywords.Add("OUTLINES"); tcp2Keywords.Add("TCP2_OUTLINE_CONST_SIZE"); break;
case "Outline Z-Correct": tcp2Keywords.Add("OUTLINES"); tcp2Keywords.Add("TCP2_ZSMOOTH_ON"); break;
case "OutlineConst Z-Correct": tcp2Keywords.Add("OUTLINES"); tcp2Keywords.Add("TCP2_OUTLINE_CONST_SIZE"); tcp2Keywords.Add("TCP2_ZSMOOTH_ON"); break;
case "Rim Outline": tcp2Keywords.Add("TCP2_RIMO"); break;
default: Debug.LogWarning("Material: " + m.name + ", Shader: " + originalShader + "\nUnrecognized nameParts[1]: '" + nameParts[1] + "'"); break;
}
bool isMobile = false;
switch(nameParts[2])
{
case "OneDirLight": isMobile = true; break;
case "MultipleLights": isMobile = false; break;
default: Debug.LogWarning("Material: " + m.name + ", Shader: " + originalShader + "\nUnrecognized nameParts[2]: '" + nameParts[2] + "'"); break;
}
if(nameParts[3].Contains("Bumped")) tcp2Keywords.Add("TCP2_BUMP");
if(nameParts[3].Contains("Rim")) tcp2Keywords.Add("TCP2_RIM");
if(nameParts[3].Contains("Specular")) tcp2Keywords.Add("TCP2_SPEC");
string features = originalShader + "\nMOBILE: " + isMobile.ToString();
foreach(string kw in tcp2Keywords)
{
features += "\n" + kw;
}
// Variables conversion
Color highlightColor = m.HasProperty("_Color") ? m.GetColor("_Color") : Color.white;
float rimMin = m.HasProperty("_RimPower") ? (m.GetFloat("_RimPower") / 4f) : 0.5f;
float outline = m.HasProperty("_Outline") ? (m.GetFloat("_Outline") * 100f) : 1.0f;
//Find TCP2 Shader
string[] keywords = tcp2Keywords.ToArray();
string tcp2ShaderName = GetShaderFromKeywords(isMobile, keywords);
Shader tcp2Shader = Shader.Find(tcp2ShaderName);
if(tcp2Shader == null)
{
Debug.LogWarning("Skipping '" + m.name + "'\nCouldn't find corresponding TCP2 shader\nGenerated shader name: " + tcp2ShaderName);
return;
}
else
{
// Valid TCP2 Shader found
Undo.RecordObject(m, string.Format("Material TCP2 conversion", m.name));
m.shader = tcp2Shader;
m.shaderKeywords = keywords;
// Set converted variables
//Highlight Color
if(m.HasProperty("_HColor"))
{
m.SetColor("_HColor", highlightColor);
m.SetColor("_Color", Color.white);
}
else
{
Debug.LogWarning("Property _HColor not found in resulting TCP2 shader:\n" + tcp2ShaderName);
}
//Rim power
if(m.HasProperty("_RimMin"))
{
m.SetFloat("_RimMin", rimMin);
}
//Outline width
if(m.HasProperty("_Outline"))
{
m.SetFloat("_Outline", outline);
}
EditorUtility.SetDirty(m);
}
}
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);
}
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 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);
}
Color GetColorIfNoTexture(Material mat, ShaderTextureProperty texProperty)
{
if (texProperty.isNormalMap){
return new Color(.5f,.5f,1f);
} else if (texProperty.name.Equals("_MainTex")){
if (mat != null && mat.HasProperty("_Color")){
try{ //need try because can't garantee _Color is a color
return mat.GetColor("_Color");
} catch (Exception){}
}
} else if (texProperty.name.Equals ("_SpecGlossMap")){
if (mat != null && mat.HasProperty("_SpecColor")){
try{ //need try because can't garantee _Color is a color
Color c = mat.GetColor("_SpecColor");
if (mat.HasProperty("_Glossiness")){
try{
c.a = mat.GetFloat("_Glossiness");
} catch (Exception){}
}
Debug.LogWarning(c);
return c;
} catch (Exception){}
}
} else if (texProperty.name.Equals("_MetallicGlossMap")){
if (mat != null && mat.HasProperty("_Metallic")){
try{ //need try because can't garantee _Metallic is a float
float v = mat.GetFloat("_Metallic");
Color c = new Color(v,v,v);
if (mat.HasProperty("_Glossiness")){
try{
c.a = mat.GetFloat("_Glossiness");
} catch (Exception){}
}
return c;
} catch (Exception){}
}
} else if (texProperty.name.Equals("_ParallaxMap")){
return new Color(0f,0f,0f,0f);
} else if (texProperty.name.Equals("_OcclusionMap")){
return new Color(1f,1f,1f,1f);
} else if (texProperty.name.Equals("_EmissionMap")){
if (mat != null){
if (mat.HasProperty("_EmissionScaleUI")){
//Standard shader has weird behavior if EmissionMap has never
//been set then no EmissionColorUI color picker. If has ever
//been set then is EmissionColorUI color picker.
if (mat.HasProperty("_EmissionColor") &&
mat.HasProperty ("_EmissionColorUI")){
try{
Color c1 = mat.GetColor("_EmissionColor");
Color c2 = mat.GetColor("_EmissionColorUI");
float f = mat.GetFloat("_EmissionScaleUI");
if (c1 == new Color(0f,0f,0f,0f) &&
c2 == new Color(1f,1f,1f,1f)){
//is virgin Emission values
return new Color(f,f,f,f);
} else { //non virgin Emission values
return c2;
}
} catch(Exception){}
} else {
try{ //need try because can't garantee _Color is a color
float f = mat.GetFloat("_EmissionScaleUI");
return new Color(f,f,f,f);
} catch (Exception){}
}
}
}
} else if (texProperty.name.Equals("_DetailMask")){
return new Color(0f,0f,0f,0f);
}
return new Color(1f,1f,1f,0f);
}
private BabylonMaterial DumpMaterial(Material material, Renderer renderer)
{
if (!materialsDictionary.ContainsKey(material.name))
{
var bMat = new BabylonMaterial
{
name = material.name,
id = Guid.NewGuid().ToString(),
diffuse = new float[4],
specular = new float[4]
};
bMat.diffuse[0] = 1.0f;
bMat.diffuse[1] = 1.0f;
bMat.diffuse[2] = 1.0f;
bMat.diffuse[3] = 1.0f;
if (material.HasProperty("_Color"))
{
bMat.diffuse = material.color.ToFloat();
}
if (material.HasProperty("_SpecColor"))
{
var specColor = material.GetColor("_SpecColor");
bMat.specular = specColor.ToFloat();
}
if (material.HasProperty("_Shininess"))
{
var specShininess = material.GetFloat("_Shininess");
bMat.specularPower = specShininess * 128;
}
if (material.HasProperty("_Emission"))
{
var emissiveColor = material.GetColor("_Emission");
bMat.emissive = emissiveColor.ToFloat();
}
if (material.mainTexture)
{
var mainTexturePath = AssetDatabase.GetAssetPath(material.mainTexture);
bMat.diffuseTexture = new BabylonTexture
{
uScale = material.mainTextureScale.x,
vScale = material.mainTextureScale.y,
uOffset = material.mainTextureOffset.x,
vOffset = material.mainTextureOffset.y
};
var mainTexture2D = material.mainTexture as Texture2D;
CopyTexture(mainTexturePath, mainTexture2D, bMat.diffuseTexture);
var alphaCuttOff = 0f;
if (material.HasProperty("_Cutoff"))
{
alphaCuttOff = material.GetFloat("_Cutoff");
}
if ((mainTexture2D && mainTexture2D.alphaIsTransparency) || alphaCuttOff > 0)
{
bMat.diffuseTexture.hasAlpha = true;
bMat.backFaceCulling = false;
}
bMat.diffuse[0] = 1.0f;
bMat.diffuse[1] = 1.0f;
bMat.diffuse[2] = 1.0f;
bMat.diffuse[3] = 1.0f;
}
bMat.bumpTexture = DumpTextureFromMaterial(material, "_BumpMap");
bMat.emissiveTexture = DumpTextureFromMaterial(material, "_Illum");
bMat.ambientTexture = DumpTextureFromMaterial(material, "_LightMap");
bMat.reflectionTexture = DumpTextureFromMaterial(material, "_Cube");
//if (bMat.ambientTexture == null && renderer.lightmapIndex >= 0 && renderer.lightmapIndex != 255 && LightmapSettings.lightmaps.Length > renderer.lightmapIndex)
//{
// var lightmap = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapFar;
// bMat.ambientTexture = DumpTexture(lightmap);
// bMat.ambientTexture.coordinatesIndex = 1;
// bMat.ambientTexture.uScale = renderer.lightmapTilingOffset.x;
// bMat.ambientTexture.vScale = renderer.lightmapTilingOffset.y;
// bMat.ambientTexture.uOffset = renderer.lightmapTilingOffset.z;
// bMat.ambientTexture.vOffset = renderer.lightmapTilingOffset.w;
//}
materialsDictionary.Add(bMat.name, bMat);
return bMat;
}
return materialsDictionary[material.name];
}
private BabylonMaterial DumpMaterial(Material material, Renderer renderer)
{
var materialNotSupported = false;
if (!materialsDictionary.ContainsKey(material.name))
{
var bMat = new BabylonStandardMaterial
{
name = material.name,
id = Guid.NewGuid().ToString(),
diffuse = new float[4],
specular = new float[4]
};
bMat.diffuse[0] = 1.0f;
bMat.diffuse[1] = 1.0f;
bMat.diffuse[2] = 1.0f;
bMat.diffuse[3] = 1.0f;
if (material.HasProperty("_Color"))
{
bMat.diffuse = material.color.ToFloat();
}
if (material.HasProperty("_SpecColor"))
{
var specColor = material.GetColor("_SpecColor");
bMat.specular = specColor.ToFloat();
}
if (material.HasProperty("_Shininess"))
{
var specShininess = material.GetFloat("_Shininess");
bMat.specularPower = specShininess * 128;
}
if (material.HasProperty("_Emission"))
{
var emissiveColor = material.GetColor("_Emission");
bMat.emissive = emissiveColor.ToFloat();
}
if (material.mainTexture && material.mainTexture.GetType().FullName == "UnityEngine.ProceduralTexture")
{
materialNotSupported = true;
Debug.LogWarning("ProceduralTexture: " + material.mainTexture.name + " not supported by Babylon.js");
}
if (material.mainTexture && !(materialNotSupported))
{
var mainTexturePath = AssetDatabase.GetAssetPath(material.mainTexture);
bMat.diffuseTexture = new BabylonTexture
{
uScale = material.mainTextureScale.x,
vScale = material.mainTextureScale.y,
uOffset = material.mainTextureOffset.x,
vOffset = material.mainTextureOffset.y
};
var mainTexture2D = material.mainTexture as Texture2D;
CopyTexture(mainTexturePath, mainTexture2D, bMat.diffuseTexture);
var alphaCuttOff = 0f;
if (material.HasProperty("_Cutoff"))
{
alphaCuttOff = material.GetFloat("_Cutoff");
}
if ((mainTexture2D && mainTexture2D.alphaIsTransparency) || alphaCuttOff > 0)
{
bMat.diffuseTexture.hasAlpha = true;
bMat.backFaceCulling = false;
}
bMat.diffuse[0] = 1.0f;
bMat.diffuse[1] = 1.0f;
bMat.diffuse[2] = 1.0f;
bMat.diffuse[3] = 1.0f;
}
bMat.bumpTexture = DumpTextureFromMaterial(material, "_BumpMap");
bMat.emissiveTexture = DumpTextureFromMaterial(material, "_Illum");
bMat.ambientTexture = DumpTextureFromMaterial(material, "_LightMap");
bMat.reflectionTexture = DumpTextureFromMaterial(material, "_Cube");
if (bMat.ambientTexture == null && renderer.lightmapIndex >= 0 && renderer.lightmapIndex != 255 && LightmapSettings.lightmaps.Length > renderer.lightmapIndex)
{
var lightmap = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapFar;
bMat.lightmapTexture = DumpTexture(lightmap, isLightmap: true);
bMat.lightmapTexture.coordinatesIndex = 1;
bMat.useLightmapAsShadowmap = true;
bMat.lightmapTexture.uScale = renderer.lightmapScaleOffset.x;
bMat.lightmapTexture.vScale = renderer.lightmapScaleOffset.y;
bMat.lightmapTexture.uOffset = renderer.lightmapScaleOffset.z;
bMat.lightmapTexture.vOffset = renderer.lightmapScaleOffset.w;
}
materialsDictionary.Add(bMat.name, bMat);
return bMat;
}
return materialsDictionary[material.name];
}
private static float GetMaterialFloat(Material material, string propertyID, out bool success)
{
success = false;
if (!material.HasProperty(propertyID))
{
return 0f;
}
success = true;
return material.GetFloat(propertyID);
}
private BabylonMaterial DumpPBRMaterial(Material material, Renderer renderer)
{
if (!materialsDictionary.ContainsKey(material.name))
{
var bMat = new BabylonPBRMaterial
{
name = material.name,
id = Guid.NewGuid().ToString(),
albedoColor = new float[4]
};
if (material.HasProperty("_Color"))
{
bMat.albedoColor = material.color.ToFloat();
}
bMat.albedoTexture = DumpTextureFromMaterial(material, "_MainTex");
if (material.HasProperty("_Glossiness"))
{
bMat.microSurface = material.GetFloat("_Glossiness");
}
if (material.HasProperty("_Metallic"))
{
var metallic = material.GetFloat("_Metallic");
bMat.reflectivityColor = new float[] { metallic, metallic, metallic };
}
bMat.bumpTexture = DumpTextureFromMaterial(material, "_BumpMap");
materialsDictionary.Add(bMat.name, bMat);
return bMat;
}
return materialsDictionary[material.name];
}
private static GLTF.Schema.Material ConvertSeinPBRMaterial(UnityEngine.Material mat, ExporterEntry entry)
{
var material = new GLTF.Schema.Material();
material.Name = mat.name;
bool isMetal = mat.GetInt("workflow") == 0;
bool isUnlit = mat.GetInt("unlit") == 1;
if (!isMetal)
{
// special
entry.AddExtension("KHR_materials_pbrSpecularGlossiness");
material.Extensions = new Dictionary <string, Extension>();
}
else
{
material.PbrMetallicRoughness = new PbrMetallicRoughness();
}
bool hasTransparency = ProcessTransparency(mat, material);
if (isUnlit || isMetal)
{
if (mat.GetTexture("_baseColorMap") != null)
{
var id = entry.SaveTexture((Texture2D)mat.GetTexture("_baseColorMap"), hasTransparency);
material.PbrMetallicRoughness.BaseColorTexture = new TextureInfo {
Index = id
};
}
if (mat.GetColor("_baseColor") != null)
{
Color c = mat.GetColor("_baseColor");
material.PbrMetallicRoughness.BaseColorFactor = Utils.ExportColor(c);
}
}
if (isUnlit)
{
if (material.Extensions == null)
{
material.Extensions = new Dictionary <string, Extension>();
}
ExtensionManager.Serialize(ExtensionManager.GetExtensionName(typeof(KHR_materials_unlitExtensionFactory)), entry, material.Extensions);
}
else if (isMetal)
{
bool hasPBRMap = mat.GetTexture("_metallicMap") != null;
if (hasPBRMap)
{
Texture2D metallicTexture = (Texture2D)mat.GetTexture("_metallicMap");
Texture2D roughnessTexture = (Texture2D)mat.GetTexture("_roughnessMap");
Texture2D occlusion = (Texture2D)mat.GetTexture("_occlusionMap");
var metalRoughTextureAo = CreateOcclusionMetallicRoughnessTexture(
ref metallicTexture, ref roughnessTexture, ref occlusion
);
var assetPath = AssetDatabase.GetAssetPath(metallicTexture);
var ext = Path.GetExtension(assetPath);
var id = entry.SaveTexture(metalRoughTextureAo, hasTransparency, assetPath.Replace(ext, "-orm") + ext);
material.PbrMetallicRoughness.MetallicRoughnessTexture = new TextureInfo {
Index = id
};
if (occlusion != null)
{
material.OcclusionTexture = new OcclusionTextureInfo
{
Index = id,
Strength = mat.GetFloat("_occlusionStrength")
};
}
}
material.PbrMetallicRoughness.MetallicFactor = mat.GetFloat("_metallic");
material.PbrMetallicRoughness.RoughnessFactor = mat.GetFloat("_roughness");
}
else
{
TextureInfo specGlossMap = null;
TextureInfo diffuseMap = null;
var diffuseColor = new GLTF.Math.Color();
if (mat.GetTexture("_baseColorMap") != null)
{
var id = entry.SaveTexture((Texture2D)mat.GetTexture("_baseColorMap"), hasTransparency);
diffuseMap = new TextureInfo {
Index = id
};
}
if (mat.GetColor("_baseColor") != null)
{
Color c = mat.GetColor("_baseColor");
diffuseColor = Utils.ExportColor(c);
}
bool hasPBRMap = mat.GetTexture("_specularGlossinessMap") != null;
if (hasPBRMap)
{
specGlossMap = new TextureInfo {
Index = entry.SaveTexture((Texture2D)mat.GetTexture("_specularGlossinessMap"), true)
};
}
var specularFactor = hasPBRMap ? Color.white : (Color)Utils.ExportColorVec4(mat.GetColor("_specular"));
var glossinessFactor = hasPBRMap ? 1.0f : mat.GetFloat("_glossiness");
if (material.Extensions == null)
{
material.Extensions = new Dictionary <string, Extension>();
}
material.Extensions.Add(
"KHR_materials_pbrSpecularGlossiness",
new KHR_materials_pbrSpecularGlossinessExtension(
diffuseColor, diffuseMap,
new GLTF.Math.Vector3(specularFactor.r, specularFactor.g, specularFactor.b),
glossinessFactor, specGlossMap
)
);
Texture2D occlusion = (Texture2D)mat.GetTexture("_occlusionMap");
if (occlusion != null)
{
material.OcclusionTexture = new OcclusionTextureInfo
{
Index = entry.SaveTexture((Texture2D)mat.GetTexture("_occlusionMap"), false),
Strength = mat.GetFloat("_occlusionStrength")
};
}
}
if (mat.GetTexture("_normalMap") != null)
{
material.NormalTexture = new NormalTextureInfo
{
Index = entry.SaveTexture((Texture2D)mat.GetTexture("_normalMap"), false),
};
}
if (mat.GetTexture("_emissionMap") != null)
{
material.EmissiveTexture = new TextureInfo
{
Index = entry.SaveTexture((Texture2D)mat.GetTexture("_emissionMap"), false),
};
}
var emissive = mat.GetColor("_emission");
if (!emissive.Equals(new Color(0, 0, 0)))
{
material.EmissiveFactor = Utils.ExportColor(emissive);
}
if (mat.GetInt("envReflection") != (int)SeinPBRShaderGUI.EnvReflection.Off || (ExporterSettings.Lighting.ambient && (RenderSettings.ambientMode == UnityEngine.Rendering.AmbientMode.Skybox || RenderSettings.ambientMode == UnityEngine.Rendering.AmbientMode.Trilight)))
{
if (material.Extensions == null)
{
material.Extensions = new Dictionary <string, Extension>();
}
ExtensionManager.Serialize(ExtensionManager.GetExtensionName(typeof(Sein_imageBasedLightingExtensionFactory)), entry, material.Extensions, mat);
}
return(material);
}
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;
}
}
}