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; }