| public GetInt ( int nameID ) : int | ||
| nameID | int | The name ID of the property retrieved by Shader.PropertyToID. |
| return | int | |
static public int GetInt(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.Int32 ret = self.GetInt(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.Int32 ret = self.GetInt(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 GetInt(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);
int o = obj.GetInt(arg0);
LuaDLL.lua_pushinteger(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);
int o = obj.GetInt(arg0);
LuaDLL.lua_pushinteger(L, o);
return(1);
}
else
{
return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.Material.GetInt"));
}
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
static public int GetInt(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.GetInt(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.GetInt(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));
}
}
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);
}
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);
}
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);
}
}
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);
}
/// <summary>
/// Converts a Unity material to a glTF material.
/// </summary>
/// <param name="uMaterial">Source material</param>
/// <param name="material">Resulting material</param>
/// <param name="gltf">Associated IGltfWriter. Is used for adding images and textures.</param>
/// <param name="logger">Logger used for reporting</param>
/// <returns>True if no errors occured, false otherwise</returns>
internal static bool ConvertMaterial(UnityEngine.Material uMaterial, out Material material, IGltfWritable gltf, ICodeLogger logger)
{
var success = true;
material = new Material {
name = uMaterial.name,
pbrMetallicRoughness = new PbrMetallicRoughness {
metallicFactor = 0,
roughnessFactor = 1.0f
}
};
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;
}
material.doubleSided = uMaterial.HasProperty(k_Cull) &&
uMaterial.GetInt(k_Cull) == (int)CullMode.Off;
if (uMaterial.IsKeywordEnabled("_EMISSION"))
{
if (uMaterial.HasProperty(k_EmissionColor))
{
material.emissive = uMaterial.GetColor(k_EmissionColor);
}
if (uMaterial.HasProperty(k_EmissionMap))
{
// var emissionTex = uMaterial.GetTexture(k_EmissionMap);
//
// if (emissionTex != null) {
// if(emissionTex is Texture2D) {
// material.emissiveTexture = ExportTextureInfo(emissionTex, TextureMapType.Emission);
// ExportTextureTransform(material.EmissiveTexture, uMaterial, "_EmissionMap");
// } else {
// logger?.Error(LogCode.TextureInvalidType, "emission", material.name );
// success = false;
// }
// }
}
}
if (
uMaterial.HasProperty(k_BumpMap) &&
(uMaterial.IsKeywordEnabled(Materials.Constants.kwNormalMap) ||
uMaterial.IsKeywordEnabled(k_KeywordBumpMap))
)
{
var normalTex = uMaterial.GetTexture(k_BumpMap);
if (normalTex != null)
{
if (normalTex is Texture2D)
{
material.normalTexture = ExportNormalTextureInfo(normalTex, TextureMapType.Bump, uMaterial, gltf);
ExportTextureTransform(material.normalTexture, uMaterial, k_BumpMap, gltf);
}
else
{
logger?.Error(LogCode.TextureInvalidType, "normal", uMaterial.name);
success = false;
}
}
}
if (uMaterial.HasProperty(k_OcclusionMap))
{
var occTex = uMaterial.GetTexture(k_OcclusionMap);
if (occTex != null)
{
// if(occTex is Texture2D) {
// material.occlusionTexture = ExportOcclusionTextureInfo(occTex, TextureMapType.Occlusion, uMaterial);
// ExportTextureTransform(material.OcclusionTexture, uMaterial, "_OcclusionMap");
// } else {
// logger?.Error(LogCode.TextureInvalidType, "occlusion", material.name );
// success = false;
// }
}
}
if (IsUnlit(uMaterial))
{
ExportUnlit(material, uMaterial, gltf, logger);
}
else if (IsPbrMetallicRoughness(uMaterial))
{
success &= ExportPbrMetallicRoughness(uMaterial, out material.pbrMetallicRoughness, gltf, logger);
}
else if (IsPbrSpecularGlossiness(uMaterial))
{
// ExportPBRSpecularGlossiness(material, uMaterial);
}
else if (uMaterial.HasProperty(k_BaseMap))
{
var mainTex = uMaterial.GetTexture(k_BaseMap);
material.pbrMetallicRoughness = new PbrMetallicRoughness {
baseColor = uMaterial.HasProperty(k_BaseColor)
? uMaterial.GetColor(k_BaseColor)
: Color.white,
baseColorTexture = mainTex == null ? null : ExportTextureInfo(mainTex, TextureMapType.Main, gltf)
};
}
else if (uMaterial.HasProperty(k_ColorTexture))
{
var mainTex = uMaterial.GetTexture(k_ColorTexture);
material.pbrMetallicRoughness = new PbrMetallicRoughness {
baseColor = uMaterial.HasProperty(k_BaseColor)
? uMaterial.GetColor(k_BaseColor)
: Color.white,
baseColorTexture = mainTex == null ? null : ExportTextureInfo(mainTex, TextureMapType.Main, gltf)
};
}
else if (uMaterial.HasProperty(k_MainTex)) //else export main texture
{
var mainTex = uMaterial.GetTexture(k_MainTex);
if (mainTex != null)
{
material.pbrMetallicRoughness = new PbrMetallicRoughness {
metallicFactor = 0, roughnessFactor = 1.0f,
baseColorTexture = ExportTextureInfo(mainTex, TextureMapType.Main, gltf)
};
// ExportTextureTransform(material.pbrMetallicRoughness.baseColorTexture, uMaterial, "_MainTex");
}
if (uMaterial.HasProperty(k_TintColor))
{
//particles use _TintColor instead of _Color
material.pbrMetallicRoughness = material.pbrMetallicRoughness ?? new PbrMetallicRoughness {
metallicFactor = 0, roughnessFactor = 1.0f
};
material.pbrMetallicRoughness.baseColor = uMaterial.GetColor(k_TintColor);
}
material.doubleSided = true;
}
return(success);
}
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 void SetBlendMode (Material material, eBlendMode blendMode) {
SetKeyword(material, PremultipledAlpha, blendMode == eBlendMode.PreMultipliedAlpha);
SetKeyword(material, Multiply, blendMode == eBlendMode.Multiply);
SetKeyword(material, Multiply2x, blendMode == eBlendMode.Multiplyx2);
SetKeyword(material, Additive, blendMode == eBlendMode.Additive);
SetKeyword(material, SoftAdditive, blendMode == eBlendMode.SoftAdditive);
int renderQueue;
switch (blendMode) {
case eBlendMode.Solid:
{
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
SetRenderQueue(material, "Opaque");
renderQueue = SolidQueue;
}
break;
case eBlendMode.Additive:
{
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
SetRenderQueue(material, "Transparent");
renderQueue = TransparentQueue;
}
break;
case eBlendMode.SoftAdditive:
{
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcColor);
SetRenderQueue(material, "Transparent");
renderQueue = TransparentQueue;
}
break;
case eBlendMode.Multiply:
{
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.SrcColor);
SetRenderQueue(material, "Transparent");
renderQueue = TransparentQueue;
}
break;
case eBlendMode.Multiplyx2:
{
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.SrcColor);
SetRenderQueue(material, "Transparent");
renderQueue = TransparentQueue;
}
break;
case eBlendMode.PreMultipliedAlpha:
case eBlendMode.StandardAlpha:
default:
{
bool zWrite = material.GetFloat("_ZWrite") > 0.0f;
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
SetRenderQueue(material, zWrite ? "TransparentCutout" : "Transparent");
renderQueue = zWrite ? AlphaTestQueue : TransparentQueue;
}
break;
}
material.renderQueue = renderQueue + material.GetInt("_RenderQueue");
}
void DoSpecularMetallicArea( Material material )
{
SpecularMode specularMode = ( SpecularMode )material.GetInt( "_SpecularMode" );
if ( specularMode == SpecularMode.BlinnPhong )
{
if (specularMap.textureValue == null)
{
m_MaterialEditor.TexturePropertyTwoLines( Styles.specularMapText, specularMap, specularColor, Styles.smoothnessText, smoothness );
}
else
{
m_MaterialEditor.TexturePropertySingleLine( Styles.specularMapText, specularMap );
}
m_MaterialEditor.ShaderProperty( reflectanceMin, Styles.reflectanceMinText.text, 2 );
m_MaterialEditor.ShaderProperty( reflectanceMax, Styles.reflectanceMaxText.text, 2 );
}
else if ( specularMode == SpecularMode.Metallic )
{
if (metallicMap.textureValue == null)
m_MaterialEditor.TexturePropertyTwoLines(Styles.metallicMapText, metallicMap, metallic, Styles.smoothnessText, smoothness);
else
m_MaterialEditor.TexturePropertySingleLine(Styles.metallicMapText, metallicMap);
}
}
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);
}
/// <summary>
/// Retrieves whether material is double-sided.
/// </summary>
/// <param name="uMaterial">Material to analyze.</param>
/// <returns>True if material is double-sided, false otherwise.</returns>
protected static bool IsDoubleSided(UnityEngine.Material uMaterial)
{
return(uMaterial.HasProperty(k_Cull) &&
uMaterial.GetInt(k_Cull) == (int)CullMode.Off);
}
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 BabylonMaterial DumpStandardMaterial(Material material, int lightmapIndex = -1, Vector4 lightmapScaleOffset = default(Vector4), int lightmapCoordIndex = -1)
{
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]
};
ExporterWindow.ReportProgress(1, "Exporting standard material: " + material.name);
// Default diffuse
bMat.diffuse[0] = 1.0f;
bMat.diffuse[1] = 1.0f;
bMat.diffuse[2] = 1.0f;
bMat.diffuse[3] = 1.0f;
// Default specular
bMat.specular[0] = 0.0f;
bMat.specular[1] = 0.0f;
bMat.specular[2] = 0.0f;
bMat.specular[3] = 1.0f;
if (material.mainTexture && material.mainTexture.GetType().FullName == "UnityEngine.ProceduralTexture")
{
materialNotSupported = true;
Debug.LogWarning("ProceduralTexture: " + material.mainTexture.name + " not supported by Babylon.js");
}
if (material.HasProperty("_Shininess"))
{
var specShininess = material.GetFloat("_Shininess");
bMat.specularPower = specShininess * 128;
}
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("_Emission"))
{
if (material.GetColorNames().IndexOf("_Emission") >= 0)
{
var emissiveColor = material.GetColor("_Emission");
bMat.emissive = emissiveColor.ToFloat();
}
else if (material.GetFloatNames().IndexOf("_Emission") >= 0)
{
// TODO: Convert Lightmapper Emission Color
UnityEngine.Debug.LogWarning("Material Emission Is Float Not Color: " + material.name);
}
}
if (material.HasProperty("_AlphaMode"))
{
bMat.alphaMode = material.GetInt("_AlphaMode");
}
if (material.HasProperty("_DisableLighting"))
{
bMat.disableLighting = (material.GetInt("_DisableLighting") != 0);
}
if (material.HasProperty("_UseEmissiveAsIllumination"))
{
bMat.useEmissiveAsIllumination = (material.GetInt("_UseEmissiveAsIllumination") != 0);
}
if (material.HasProperty("_BackFaceCulling"))
{
bMat.backFaceCulling = (material.GetInt("_BackFaceCulling") != 0);
}
if (material.mainTexture && !materialNotSupported)
{
var mainTexture2D = material.mainTexture as Texture2D;
var mainTexturePath = AssetDatabase.GetAssetPath(mainTexture2D);
var alphaCuttOff = 0f;
if (material.HasProperty("_Cutoff"))
{
alphaCuttOff = material.GetFloat("_Cutoff");
}
bMat.diffuseTexture = new BabylonTexture
{
uScale = material.mainTextureScale.x,
vScale = material.mainTextureScale.y,
uOffset = material.mainTextureOffset.x,
vOffset = material.mainTextureOffset.y
};
CopyTexture(mainTexturePath, mainTexture2D, bMat.diffuseTexture);
if ((mainTexture2D && mainTexture2D.alphaIsTransparency) || alphaCuttOff > 0)
{
bMat.diffuseTexture.hasAlpha = true;
bMat.backFaceCulling = false;
}
}
// Normal map
bMat.bumpTexture = DumpTextureFromMaterial(material, "_BumpMap");
if (bMat.bumpTexture != null && material.HasProperty("_BumpScale"))
{
bMat.bumpTexture.level = material.GetFloat("_BumpScale");
}
bMat.emissiveTexture = DumpTextureFromMaterial(material, "_Illum");
bMat.ambientTexture = DumpTextureFromMaterial(material, "_LightMap");
bMat.reflectionTexture = DumpTextureFromMaterial(material, "_Cube");
// Baking override
if (exportationOptions.DefaultLightmapMode == (int)BabylonLightmapMode.FullLightBaking)
{
bMat.disableLighting = true;
bMat.useEmissiveAsIllumination = true;
}
// If no ambient texture already (ambientTexture manually set for lightmaps on standard material)
bool hasLightmap = (exportationOptions.ExportLightmaps && lightmapIndex >= 0 && lightmapIndex != 65535 && LightmapSettings.lightmaps.Length > lightmapIndex);
if (hasLightmap && bMat.ambientTexture == null)
{
var lightmap = LightmapSettings.lightmaps[lightmapIndex].lightmapLight;
var texturePath = AssetDatabase.GetAssetPath(lightmap);
if (!String.IsNullOrEmpty(texturePath))
{
ExporterWindow.ReportProgress(1, "Dumping std material lightmap: " + lightmap.name);
bMat.lightmapTexture = DumpTexture(lightmap, isLightmap: true);
bMat.lightmapTexture.coordinatesIndex = (lightmapCoordIndex >= 0) ? lightmapCoordIndex : exportationOptions.DefaultCoordinatesIndex;
bMat.useLightmapAsShadowmap = true;
bMat.lightmapTexture.uScale = lightmapScaleOffset.x;
bMat.lightmapTexture.vScale = lightmapScaleOffset.y;
bMat.lightmapTexture.uOffset = lightmapScaleOffset.z;
bMat.lightmapTexture.vOffset = lightmapScaleOffset.w;
}
}
materialsDictionary.Add(bMat.name, bMat);
return bMat;
}
return materialsDictionary[material.name];
}
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("]", "").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();
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("]", "").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();
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("]", "").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();
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("]", "").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();
if (!String.IsNullOrEmpty(doption_buffer))
{
defineList.Add(doption_buffer);
}
}
}
}
}
}
}
if (material.HasProperty("_AlphaMode")) {
babylonShaderMaterial.alphaMode = material.GetInt("_AlphaMode");
}
bool needsAlphaBlending = false;
if (material.HasProperty("_NeedsAlphaBlending")) {
needsAlphaBlending = (material.GetInt("_NeedsAlphaBlending") != 0);
}
bool needsAlphaTesting = false;
if (material.HasProperty("_NeedsAlphaTesting")) {
needsAlphaTesting = (material.GetInt("_NeedsAlphaTesting") != 0);
}
if (material.HasProperty("_BackFaceCulling")) {
babylonShaderMaterial.backFaceCulling = (material.GetInt("_BackFaceCulling") != 0);
}
babylonShaderMaterial.options = new BabylonShaderOptions();
babylonShaderMaterial.options.needAlphaBlending = needsAlphaBlending;
babylonShaderMaterial.options.needAlphaTesting = needsAlphaTesting;
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;
}
private BabylonMaterial DumpPBRMaterial(Material material, int lightmapIndex = -1, Vector4 lightmapScaleOffset = default(Vector4), bool metallic = true, int lightmapCoordIndex = -1)
{
var materialNotSupported = false;
if (materialsDictionary.ContainsKey(material.name))
{
return materialsDictionary[material.name];
}
var babylonPbrMaterial = new BabylonPBRMaterial
{
name = material.name,
id = Guid.NewGuid().ToString(),
albedo = new float[4],
useEmissiveAsIllumination = true,
useSpecularOverAlpha = true,
useRadianceOverAlpha = true,
};
ExporterWindow.ReportProgress(1, "Exporting physical material: " + material.name);
babylonPbrMaterial.environmentIntensity = RenderSettings.ambientIntensity;
if (material.mainTexture && material.mainTexture.GetType().FullName == "UnityEngine.ProceduralTexture")
{
materialNotSupported = true;
Debug.LogWarning("ProceduralTexture: " + material.mainTexture.name + " not supported by Babylon.js");
}
if (material.HasProperty("_Roughness"))
{
babylonPbrMaterial.roughness = material.GetInt("_Roughness");
}
if (material.HasProperty("_UseRoughnessFromMetallicTextureAlpha"))
{
babylonPbrMaterial.useRoughnessFromMetallicTextureAlpha = (material.GetInt("_UseRoughnessFromMetallicTextureAlpha") != 0);
}
if (material.HasProperty("_UseRoughnessFromMetallicTextureGreen"))
{
babylonPbrMaterial.useRoughnessFromMetallicTextureGreen = (material.GetInt("_UseRoughnessFromMetallicTextureGreen") != 0);
}
if (material.HasProperty("_AlphaMode"))
{
babylonPbrMaterial.alphaMode = material.GetInt("_AlphaMode");
}
if (material.HasProperty("_DisableLighting"))
{
babylonPbrMaterial.disableLighting = (material.GetInt("_DisableLighting") != 0);
}
if (material.HasProperty("_UseEmissiveAsIllumination"))
{
babylonPbrMaterial.useEmissiveAsIllumination = (material.GetInt("_UseEmissiveAsIllumination") != 0);
}
if (material.HasProperty("_BackFaceCulling"))
{
babylonPbrMaterial.backFaceCulling = (material.GetInt("_BackFaceCulling") != 0);
}
// Albedo
if (material.HasProperty("_Color"))
{
babylonPbrMaterial.albedo = material.color.ToFloat();
}
babylonPbrMaterial.albedoTexture = DumpTextureFromMaterial(material, "_MainTex");
if (material.mainTexture != null && !materialNotSupported)
{
var textureScale = material.mainTextureScale;
babylonPbrMaterial.albedoTexture.uScale = textureScale.x;
babylonPbrMaterial.albedoTexture.vScale = textureScale.y;
var textureOffset = material.mainTextureOffset;
babylonPbrMaterial.albedoTexture.uOffset = textureOffset.x;
babylonPbrMaterial.albedoTexture.vOffset = textureOffset.y;
}
// Emissive
if (material.HasProperty("_EmissionColor"))
{
babylonPbrMaterial.emissive = material.GetColor("_EmissionColor").ToFloat();
}
babylonPbrMaterial.emissiveTexture = DumpTextureFromMaterial(material, "_EmissionMap");
// Transparency
DumpTransparency(material, babylonPbrMaterial);
// Glossiess/Reflectivity
DumpGlossinessReflectivity(material, metallic, babylonPbrMaterial);
// Occlusion
babylonPbrMaterial.ambientTexture = DumpTextureFromMaterial(material, "_OcclusionMap");
if (babylonPbrMaterial.ambientTexture != null && material.HasProperty("_OcclusionStrength"))
{
babylonPbrMaterial.ambientTexture.level = material.GetFloat("_OcclusionStrength");
}
// Normal
babylonPbrMaterial.bumpTexture = DumpTextureFromMaterial(material, "_BumpMap");
if (babylonPbrMaterial.bumpTexture != null && material.HasProperty("_BumpScale"))
{
babylonPbrMaterial.bumpTexture.level = material.GetFloat("_BumpScale");
}
// Reflection
babylonPbrMaterial.reflectionTexture = DumpReflectionTexture();
// Baking Override
if (exportationOptions.DefaultLightmapMode == (int)BabylonLightmapMode.FullLightBaking)
{
babylonPbrMaterial.disableLighting = true;
babylonPbrMaterial.useEmissiveAsIllumination = true;
}
// Lightmapping
bool hasLightmap = (exportationOptions.ExportLightmaps && lightmapIndex >= 0 && lightmapIndex != 65535 && LightmapSettings.lightmaps.Length > lightmapIndex);
if (hasLightmap && babylonPbrMaterial.ambientTexture == null)
{
var lightmap = LightmapSettings.lightmaps[lightmapIndex].lightmapLight;
var texturePath = AssetDatabase.GetAssetPath(lightmap);
if (!String.IsNullOrEmpty(texturePath))
{
ExporterWindow.ReportProgress(1, "Dumping pbr material lightmap: " + lightmap.name);
babylonPbrMaterial.lightmapTexture = DumpTexture(lightmap, isLightmap: true);
babylonPbrMaterial.lightmapTexture.coordinatesIndex = (lightmapCoordIndex >= 0) ? lightmapCoordIndex : exportationOptions.DefaultCoordinatesIndex;
babylonPbrMaterial.useLightmapAsShadowmap = true;
babylonPbrMaterial.lightmapTexture.uScale = lightmapScaleOffset.x;
babylonPbrMaterial.lightmapTexture.vScale = lightmapScaleOffset.y;
babylonPbrMaterial.lightmapTexture.uOffset = lightmapScaleOffset.z;
babylonPbrMaterial.lightmapTexture.vOffset = lightmapScaleOffset.w;
}
}
materialsDictionary.Add(babylonPbrMaterial.name, babylonPbrMaterial);
return babylonPbrMaterial;
}
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 static bool ValveToStandardSingleMaterial( Material m, Shader destShaderStandard, Shader destShaderStandardSpecular )
{
if ( m.shader.name.Equals( "Valve/vr_standard" ) )
{
if ( ( m.GetTag( "OriginalShader", true ) != null ) && ( m.GetTag( "OriginalShader", true ).Length > 0 ) )
{
Debug.Log( " Converting from \"" + m.shader.name + "\"-->\"" + m.GetTag( "OriginalShader", true ) + "\": " + m.name + "\n" );
m.shader = Shader.Find( m.GetTag( "OriginalShader", true ) );
return true;
}
else if ( m.GetInt( "_SpecularMode" ) == 2 )
{
// Metallic specular
Debug.Log( " Converting from \"" + m.shader.name + "\"-->\"" + destShaderStandard.name + "\": " + m.name + "\n" );
m.shader = destShaderStandard;
return true;
}
else
{
// Regular specular
Debug.Log( " Converting from \"" + m.shader.name + "\"-->\"" + destShaderStandardSpecular.name + "\": " + m.name + "\n" );
m.shader = destShaderStandardSpecular;
return true;
}
}
return false;
}
