public override void DrawFeatureGUI(MicroSplatKeywords keywords) { windParticulate = (ParticulateMode)EditorGUILayout.EnumPopup(CWindParticulate, windParticulate); if (windParticulate != ParticulateMode.None) { EditorGUI.indentLevel++; windUpFilter = EditorGUILayout.Toggle(CUpFilter, windUpFilter); EditorGUI.indentLevel--; } glitter = EditorGUILayout.Toggle(CGlitter, glitter); if (keywords.IsKeywordEnabled("_SNOW")) { snowParticulate = (ParticulateMode)EditorGUILayout.EnumPopup(CSnowParticulate, snowParticulate); if (snowParticulate != ParticulateMode.None) { EditorGUI.indentLevel++; snowUpFilter = EditorGUILayout.Toggle(CUpFilter, windUpFilter); EditorGUI.indentLevel--; } snowGlitter = EditorGUILayout.Toggle(CSnowGlitter, snowGlitter); } else { snowParticulate = ParticulateMode.None; snowGlitter = false; } }
public override void DrawShaderGUI(MicroSplatShaderGUI shaderGUI, MicroSplatKeywords keywords, Material mat, MaterialEditor materialEditor, MaterialProperty[] props) { if (alphaHole != AlphaHoleMode.None || alphaBelowHeight) { if (MicroSplatUtilities.DrawRollup("Alpha")) { if (mat.HasProperty("_AlphaData") && alphaHole == AlphaHoleMode.SplatIndex || alphaBelowHeight) { Vector4 vals = shaderGUI.FindProp("_AlphaData", props).vectorValue; Vector4 newVals = vals; if (alphaHole == AlphaHoleMode.SplatIndex) { newVals.x = (int)EditorGUILayout.IntSlider(CTextureIndex, (int)vals.x, 0, 16); } if (alphaBelowHeight) { newVals.y = EditorGUILayout.FloatField(CWaterLevel, vals.y); } if (newVals != vals) { shaderGUI.FindProp("_AlphaData", props).vectorValue = newVals; } } else if (mat.HasProperty("_AlphaHoleTexture")) { materialEditor.TexturePropertySingleLine(CAlphaTexture, shaderGUI.FindProp("_AlphaHoleTexture", props)); } } } }
static protected bool DrawPerTexPopUp(int curIdx, int pixel, string keyword, MicroSplatKeywords keywords, MicroSplatPropData propData, Channel channel, GUIContent label, GUIContent[] options) { EditorGUILayout.BeginHorizontal(); bool enabled = PerTexToggle(keywords, keyword); GUI.enabled = enabled; Color c = propData.GetValue(curIdx, pixel); float v = c[(int)channel]; EditorGUI.BeginChangeCheck(); int selected = EditorGUILayout.Popup(label, (int)v, options); if (EditorGUI.EndChangeCheck()) { c [(int)channel] = selected; propData.SetValue(curIdx, pixel, c); } if (GUILayout.Button("All", GUILayout.Width(40))) { for (int i = 0; i < 32; ++i) { Color nv = propData.GetValue(i, pixel); nv[(int)channel] = selected; propData.SetValue(i, pixel, nv); } } GUI.enabled = true; drawPertexToggle = true; EditorGUILayout.EndHorizontal(); return(enabled); }
public override void DrawShaderGUI(MicroSplatShaderGUI shaderGUI, MicroSplatKeywords keywords, Material mat, MaterialEditor materialEditor, MaterialProperty[] props) { if (triplanarMode != TriplanarMode.None) { if (MicroSplatUtilities.DrawRollup("Triplanar") && mat.HasProperty("_TriplanarContrast")) { materialEditor.ShaderProperty(shaderGUI.FindProp("_TriplanarContrast", props), CTriplanarContrast); if (mat.HasProperty("_TriplanarUVScale")) { EditorGUI.BeginChangeCheck(); Vector4 uvScale = shaderGUI.FindProp("_TriplanarUVScale", props).vectorValue; Vector2 scl = new Vector2(uvScale.x, uvScale.y); Vector2 offset = new Vector2(uvScale.z, uvScale.w); scl = EditorGUILayout.Vector2Field("Triplanar UV Scale", scl); offset = EditorGUILayout.Vector2Field("Triplanar UV Offset", offset); if (EditorGUI.EndChangeCheck()) { uvScale.x = scl.x; uvScale.y = scl.y; uvScale.z = offset.x; uvScale.w = offset.y; shaderGUI.FindProp("_TriplanarUVScale", props).vectorValue = uvScale; EditorUtility.SetDirty(mat); } } } } }
static bool PerTexToggle(MicroSplatKeywords keywords, string keyword) { if (drawPertexToggle) { bool enabled = keywords.IsKeywordEnabled(keyword); bool newEnabled = EditorGUILayout.Toggle(enabled, GUILayout.Width(20)); if (enabled != newEnabled) { if (newEnabled) { keywords.EnableKeyword(keyword); } else { keywords.DisableKeyword(keyword); } } return(newEnabled); } else { EditorGUILayout.LabelField("", GUILayout.Width(noPerTexToggleWidth)); drawPertexToggle = true; return(keywords.IsKeywordEnabled(keyword)); } }
public static MicroSplatKeywords FindOrCreateKeywords(Material mat) { if (mat == null) { return(null); } var path = AssetDatabase.GetAssetPath(mat); if (string.IsNullOrEmpty(path)) { Debug.LogWarning("Material has no path"); // not sure what to do about this case. Mat should always have a path path = "Assets/MicroSplatKeywords.mat"; } path = path.Replace("\\", "/"); path = path.Replace(".mat", "_keywords.asset"); MicroSplatKeywords keywords = AssetDatabase.LoadAssetAtPath <MicroSplatKeywords>(path); if (keywords == null) { keywords = ScriptableObject.CreateInstance <MicroSplatKeywords>(); keywords.keywords = new List <string>(mat.shaderKeywords); AssetDatabase.CreateAsset(keywords, path); UnityEditor.AssetDatabase.SaveAssets(); mat.shaderKeywords = null; } return(keywords); }
protected bool DrawGlobalToggle(string keyword, MicroSplatKeywords keywords) { bool b = keywords.IsKeywordEnabled(keyword); if (globalButtonPressedStyle == null) { globalButtonPressedStyle = new GUIStyle(GUI.skin.label); globalButtonPressedStyle.normal.background = new Texture2D(1, 1); globalButtonPressedStyle.normal.background.SetPixel(0, 0, Color.yellow); globalButtonPressedStyle.normal.background.Apply(); globalButtonPressedStyle.normal.textColor = Color.black; } bool pressed = (GUILayout.Button(globalButton, b ? globalButtonPressedStyle : GUI.skin.label, GUILayout.Width(14))); if (pressed) { if (b) { keywords.DisableKeyword(keyword); } else { keywords.EnableKeyword(keyword); } b = !b; EditorUtility.SetDirty(keywords); } return(b); }
static Material SetupMaterial(MicroSplatKeywords kwds, Material mat, MicroSplatBaseFeatures.DebugOutput debugOutput, bool useDebugTopo) { MicroSplatShaderGUI.MicroSplatCompiler comp = new MicroSplatShaderGUI.MicroSplatCompiler(); List<string> keywords = new List<string>(kwds.keywords); RemoveKeyword(keywords, "_SNOW"); RemoveKeyword(keywords, "_TESSDISTANCE"); RemoveKeyword(keywords, "_WINDPARTICULATE"); RemoveKeyword(keywords, "_SNOWPARTICULATE"); RemoveKeyword(keywords, "_GLITTER"); RemoveKeyword(keywords, "_SNOWGLITTER"); keywords.Add(FeatureFromOutput(debugOutput).ToString()); if (useDebugTopo) { keywords.Add("_DEBUG_USE_TOPOLOGY"); } string shader = comp.Compile(keywords.ToArray(), "RenderBake_" + debugOutput.ToString()); Shader s = ShaderUtil.CreateShaderAsset(shader); Material renderMat = new Material(mat); renderMat.shader = s; return renderMat; }
//GUIContent CShadowMap = new GUIContent("Shadow Map", "Shadow Map for distant terrain"); public override void DrawShaderGUI(MicroSplatShaderGUI shaderGUI, MicroSplatKeywords keywords, Material mat, MaterialEditor materialEditor, MaterialProperty[] props) { if ((grassMap || shadowMap) && MicroSplatUtilities.DrawRollup("Vegetation Studio")) { if (grassMap && mat.HasProperty("_VSTint")) { EditorGUI.BeginChangeCheck(); var c = mat.GetColor("_VSTint"); c = EditorGUILayout.ColorField(CShaderTint, c); if (EditorGUI.EndChangeCheck()) { mat.SetColor("_VSTint", c); EditorUtility.SetDirty(mat); } } if (shadowMap && mat.HasProperty("_VSShadowMap")) { var offsetProp = shaderGUI.FindProp("_VSShadowMapOffsetStrength", props); Vector4 v = offsetProp.vectorValue; EditorGUI.BeginChangeCheck(); //v.x = EditorGUILayout.FloatField("Offset", v.x); v.y = EditorGUILayout.Slider("Min Tree Height", v.y, 0, 1.0f); v.z = EditorGUILayout.Slider("Shadow Strength", v.z, 0, 1.0f); v.w = EditorGUILayout.Slider("Shadow Ambient", v.w, 0, 1.0f); if (EditorGUI.EndChangeCheck()) { offsetProp.vectorValue = v; } } } }
public override void DrawFeatureGUI(MicroSplatKeywords keywords) { if (keywords.IsKeywordEnabled("_MICROMESH")) { return; } bool old = terrainBlend; terrainBlend = EditorGUILayout.Toggle(CTerrainBlend, terrainBlend); if (old) { EditorGUI.indentLevel++; objectNormalBlend = EditorGUILayout.Toggle(CObjectNormalBlend, objectNormalBlend); disableAlphaControl = EditorGUILayout.Toggle(CDisableAlphaControl, disableAlphaControl); blendNoise = (BlendNoise)EditorGUILayout.EnumPopup(CBlendNoise, blendNoise); disableAlphaHoles = EditorGUILayout.Toggle(CDisableAlphaHoles, disableAlphaHoles); if (keywords.IsKeywordEnabled("_DETAILNOISE") || keywords.IsKeywordEnabled("_ANTITILEARRAYDETAIL")) { disableDetailNoise = EditorGUILayout.Toggle(CDisableDetailNoise, disableDetailNoise); } if (keywords.IsKeywordEnabled("_DISTANCENOISE") || keywords.IsKeywordEnabled("_ANTITILEARRAYDISTANCE")) { disableDistanceNoise = EditorGUILayout.Toggle(CDisableDistanceNoise, disableDistanceNoise); } if (keywords.IsKeywordEnabled("_DISTANCERESAMPLE")) { disableDistanceResampling = EditorGUILayout.Toggle(CDisableDistanceResample, disableDistanceResampling); } EditorGUI.indentLevel--; } }
public override void DrawFeatureGUI(MicroSplatKeywords keywords) { if (!keywords.IsKeywordEnabled("_MICROVERTEXMESH") || (keywords.IsKeywordEnabled("_MSRENDERLOOP_UNITYLD"))) { isTessellated = EditorGUILayout.Toggle(CShaderTessellation, isTessellated); } parallax = (ParallaxMode)EditorGUILayout.EnumPopup(CParallax, parallax); }
public override void DrawShaderGUI(MicroSplatShaderGUI shaderGUI, MicroSplatKeywords keywords, Material mat, MaterialEditor materialEditor, MaterialProperty[] props) { if (MicroSplatUtilities.DrawRollup("Splats")) { var albedoMap = shaderGUI.FindProp("_Diffuse", props); var normalMap = shaderGUI.FindProp("_NormalSAO", props); materialEditor.TexturePropertySingleLine(CAlbedoTex, albedoMap); if (!disableNormals) { if (packMode == TextureArrayConfig.PackingMode.Fastest) { materialEditor.TexturePropertySingleLine(CNormalSpec, normalMap); } else { materialEditor.TexturePropertySingleLine(CNormal, normalMap); } } if (emissiveArray && mat.HasProperty("_EmissiveMetal")) { var emisMap = shaderGUI.FindProp("_EmissiveMetal", props); materialEditor.TexturePropertySingleLine(CEmisMetal, emisMap); } if (packMode == TextureArrayConfig.PackingMode.Quality && mat.HasProperty("_SmoothAO")) { var smoothAO = shaderGUI.FindProp("_SmoothAO", props); materialEditor.TexturePropertySingleLine(CSmoothAO, smoothAO); } if (!disableHeightBlend) { var contrastProp = shaderGUI.FindProp("_Contrast", props); contrastProp.floatValue = EditorGUILayout.Slider(CInterpContrast, contrastProp.floatValue, 1.0f, 0.0001f); } if (!keywords.IsKeywordEnabled("_TRIPLANAR")) { EditorGUI.BeginChangeCheck(); Vector4 uvScale = shaderGUI.FindProp("_UVScale", props).vectorValue; Vector2 scl = new Vector2(uvScale.x, uvScale.y); Vector2 offset = new Vector2(uvScale.z, uvScale.w); scl = EditorGUILayout.Vector2Field("Global UV Scale", scl); offset = EditorGUILayout.Vector2Field("Global UV Offset", offset); if (EditorGUI.EndChangeCheck()) { uvScale.x = scl.x; uvScale.y = scl.y; uvScale.z = offset.x; uvScale.w = offset.y; shaderGUI.FindProp("_UVScale", props).vectorValue = uvScale; EditorUtility.SetDirty(mat); } } } }
public override void DrawFeatureGUI(MicroSplatKeywords keywords) { wetness = EditorGUILayout.Toggle(CWetness, wetness); if (wetness) { EditorGUI.indentLevel++; heightWetness = EditorGUILayout.Toggle(CHeightWetness, heightWetness); EditorGUI.indentLevel--; } puddles = EditorGUILayout.Toggle(CPuddles, puddles); if (puddles) { EditorGUI.indentLevel++; rainDrops = EditorGUILayout.Toggle(CRainDrops, rainDrops); EditorGUI.indentLevel--; } streams = EditorGUILayout.Toggle(CStreams, streams); if (streams) { EditorGUI.indentLevel++; heightDampStreams = EditorGUILayout.Toggle(CHeightDampStreams, heightDampStreams); EditorGUI.indentLevel--; } lava = EditorGUILayout.Toggle(CLava, lava); if (lava) { EditorGUI.indentLevel++; heightDampLava = EditorGUILayout.Toggle(CHeightDampLava, heightDampLava); #if __MICROSPLAT_TEXTURECLUSTERS__ lavaStochastic = EditorGUILayout.Toggle(CLavaStochastic, lavaStochastic); #endif EditorGUI.indentLevel--; } if ((streams || lava) && !keywords.IsKeywordEnabled("_MICROMESH")) { dynamicFlows = EditorGUILayout.Toggle(CDynamicFlows, dynamicFlows); } else { dynamicFlows = false; } if (keywords.IsKeywordEnabled("_SNOW")) { wetnessMaskSnow = EditorGUILayout.Toggle(CWetnessMaskSnow, wetnessMaskSnow); } else { wetnessMaskSnow = false; } specularFade = EditorGUILayout.Toggle(CSpecularFade, specularFade); }
public override void DrawPerTextureGUI(int index, MicroSplatKeywords keywords, Material mat, MicroSplatPropData propData) { InitPropData(8, propData, new Color(1.0f, 0, 0, 0)); //snow strength if (snow == SnowMode.Rich) { perTexSnow = DrawPerTexFloatSlider(index, 8, GetFeatureName(SnowDefineFeature._PERTEXSNOWSTRENGTH), keywords, propData, Channel.R, CPerTexSnow, 0, 1); } }
public void Pack(MicroSplatKeywords keywords) { var pck = Pack(); for (int i = 0; i < pck.Length; ++i) { keywords.EnableKeyword(pck[i]); } }
bool DrawRenderLoopGUI(MicroSplatKeywords keywords, Material targetMat) { #if UNITY_2018_1_OR_NEWER // init render loop name list if (renderLoopNames == null || renderLoopNames.Length != availableRenderLoops.Count) { var rln = new List <GUIContent>(); for (int i = 0; i < availableRenderLoops.Count; ++i) { rln.Add(new GUIContent(availableRenderLoops[i].GetDisplayName())); } renderLoopNames = rln.ToArray(); } if (renderLoopNames.Length == 1) { return(false); } int curRenderLoopIndex = 0; for (int i = 0; i < keywords.keywords.Count; ++i) { string s = keywords.keywords[i]; for (int j = 0; j < availableRenderLoops.Count; ++j) { if (s == availableRenderLoops[j].GetRenderLoopKeyword()) { curRenderLoopIndex = j; compiler.renderLoop = availableRenderLoops[j]; break; } } } int oldIdx = curRenderLoopIndex; curRenderLoopIndex = EditorGUILayout.Popup(CRenderLoop, curRenderLoopIndex, renderLoopNames); if (oldIdx != curRenderLoopIndex && curRenderLoopIndex >= 0 && curRenderLoopIndex < availableRenderLoops.Count) { if (compiler.renderLoop != null) { keywords.DisableKeyword(compiler.renderLoop.GetRenderLoopKeyword()); } compiler.renderLoop = availableRenderLoops[curRenderLoopIndex]; keywords.EnableKeyword(compiler.renderLoop.GetRenderLoopKeyword()); return(true); } #endif #if UNITY_2018_3_OR_NEWER if (targetMat != null && !targetMat.enableInstancing) { EditorUtility.SetDirty(targetMat); targetMat.enableInstancing = true; } #endif return(false); }
public void Compile(Material m, string shaderName = null) { int hash = 0; MicroSplatKeywords keywords = MicroSplatUtilities.FindOrCreateKeywords(m); for (int i = 0; i < keywords.keywords.Count; ++i) { hash += 31 + keywords.keywords [i].GetHashCode(); } var path = AssetDatabase.GetAssetPath(m.shader); string nm = m.shader.name; if (!string.IsNullOrEmpty(shaderName)) { nm = shaderName; } string baseName = "Hidden/" + nm + "_Base" + hash.ToString(); string terrainShader = Compile(keywords.keywords.ToArray(), nm, baseName); if (renderLoop != null) { keywords.EnableKeyword(renderLoop.GetRenderLoopKeyword()); } GenerateAuxShaders(nm, path, keywords.keywords); MicroSplatUtilities.Checkout(path); System.IO.File.WriteAllText(path, terrainShader); if (!keywords.IsKeywordEnabled("_MICROMESH") && !keywords.IsKeywordEnabled("_MICROVERTEXMESH") && !keywords.IsKeywordEnabled("_MEGASPLAT") && !keywords.IsKeywordEnabled("_MICROTERRAINMESH")) { // generate fallback string[] oldKeywords = new string[keywords.keywords.Count]; System.Array.Copy(keywords.keywords.ToArray(), oldKeywords, keywords.keywords.Count); keywords.DisableKeyword("_TESSDISTANCE"); keywords.DisableKeyword("_PARALLAX"); keywords.DisableKeyword("_DETAILNOISE"); keywords.EnableKeyword("_MICROSPLATBASEMAP"); string fallback = Compile(keywords.keywords.ToArray(), baseName); keywords.keywords = new List <string> (oldKeywords); string fallbackPath = path.Replace(".shader", "_Base.shader"); MicroSplatUtilities.Checkout(fallbackPath); System.IO.File.WriteAllText(fallbackPath, fallback); } EditorUtility.SetDirty(m); AssetDatabase.Refresh(); #if __MICROSPLAT_MESH__ MicroSplatMesh.ClearMaterialCache(); #endif MicroSplatObject.SyncAll(); }
public override void DrawFeatureGUI(MicroSplatKeywords keywords) { triplanarMode = (TriplanarMode)EditorGUILayout.EnumPopup(CTriplanar, triplanarMode); if (triplanarMode != TriplanarMode.None) { EditorGUI.indentLevel++; space = (TriplanarSpace)EditorGUILayout.EnumPopup(CSpace, space); EditorGUI.indentLevel--; } }
public override void DrawPerTextureGUI(int index, MicroSplatKeywords keywords, Material mat, MicroSplatPropData propData) { InitPropData(0, propData, new Color(1.0f, 1.0f, 0.0f, 0.0f)); // uvscale2, uvOffset InitPropData(1, propData, new Color(1.0f, 1.0f, 1.0f, 0.0f)); // tint, interp contrast InitPropData(2, propData, new Color(1.0f, 0.0f, 1.0f, 0.0f)); // norm str, smooth str, ao str, metal values InitPropData(3, propData, new Color(0.0f, 1.0f, 0.4f, 1.0f)); // brightness, contrast, porosity, foam InitPropData(9, propData, new Color(1, 1, 1, 1)); InitPropData(10, propData, new Color(1, 1, 1, 1)); if (perTexUVScale && samplerMode == SamplerMode.Default) { EditorGUILayout.HelpBox("On some GPUs, small artifacts can appear with per-texture UV scales. Switching sampler mode to Mip (fast) or Gradient (slow) will fix the issue", MessageType.Info); } perTexUVScale = DrawPerTexVector2Vector2(index, 0, GetFeatureName(DefineFeature._PERTEXUVSCALEOFFSET), keywords, propData, CPerTexUV, CPerTexUVOffset); if (!disableHeightBlend) { perTexInterpContrast = DrawPerTexFloatSlider(index, 1, GetFeatureName(DefineFeature._PERTEXINTERPCONTRAST), keywords, propData, Channel.A, CPerTexInterp, -1.0f, 1.0f); } perTexTint = DrawPerTexColor(index, 1, GetFeatureName(DefineFeature._PERTEXTINT), keywords, propData, CPerTexTint, false); perTexBrightness = DrawPerTexFloatSlider(index, 3, GetFeatureName(DefineFeature._PERTEXBRIGHTNESS), keywords, propData, Channel.R, CPerTexBrightness, -1.0f, 1.0f); perTexContrast = DrawPerTexFloatSlider(index, 3, GetFeatureName(DefineFeature._PERTEXCONTRAST), keywords, propData, Channel.G, CPerTexContrast, 0.1f, 3.0f); perTexSaturation = DrawPerTexFloatSlider(index, 9, GetFeatureName(DefineFeature._PERTEXSATURATION), keywords, propData, Channel.A, CPerTexSaturation, 0.0f, 2.0f); perTexNormStr = DrawPerTexFloatSlider(index, 2, GetFeatureName(DefineFeature._PERTEXNORMSTR), keywords, propData, Channel.R, CPerTexNormStr, 0.0f, 3.0f); perTexSmoothStr = DrawPerTexFloatSlider(index, 2, GetFeatureName(DefineFeature._PERTEXSMOOTHSTR), keywords, propData, Channel.G, CPerTexSmoothStr, -1.0f, 1.0f); perTexAOStr = DrawPerTexFloatSlider(index, 2, GetFeatureName(DefineFeature._PERTEXAOSTR), keywords, propData, Channel.B, CPerTexAOStr, 0.5f, 3.0f); perTexMetallic = DrawPerTexFloatSlider(index, 2, GetFeatureName(DefineFeature._PERTEXMETALLIC), keywords, propData, Channel.A, CPerTexMetallic, 0, 1); perTexHeightOffset = DrawPerTexFloatSlider(index, 10, GetFeatureName(DefineFeature._PERTEXHEIGHTOFFSET), keywords, propData, Channel.B, CPerTexHeightOffset, 0, 2); perTexHeightContrast = DrawPerTexFloatSlider(index, 10, GetFeatureName(DefineFeature._PERTEXHEIGHTCONTRAST), keywords, propData, Channel.A, CPerTexHeightContrast, 0.2f, 4); }
void RevertTerrainSplats(MicroSplatTerrain t) { MicroSplatKeywords keywords = MicroSplatUtilities.FindOrCreateKeywords(t.templateMaterial); if (keywords.IsKeywordEnabled("_CUSTOMSPLATTEXTURES")) { if (t.customControl0 == null) { Debug.LogError("Could not revert terrain because textures are missing!"); return; } UncompressTexture(t.customControl0); UncompressTexture(t.customControl1); UncompressTexture(t.customControl2); UncompressTexture(t.customControl3); UncompressTexture(t.customControl4); UncompressTexture(t.customControl5); UncompressTexture(t.customControl6); UncompressTexture(t.customControl7); int size = t.customControl0.width; int layers = t.terrain.terrainData.alphamapLayers; t.terrain.terrainData.alphamapResolution = size; var maps = t.terrain.terrainData.GetAlphamaps(0, 0, size, size); ExtractSplats(ref maps, t.customControl0, 0, layers); ExtractSplats(ref maps, t.customControl1, 4, layers); ExtractSplats(ref maps, t.customControl2, 8, layers); ExtractSplats(ref maps, t.customControl3, 12, layers); ExtractSplats(ref maps, t.customControl4, 16, layers); ExtractSplats(ref maps, t.customControl5, 20, layers); ExtractSplats(ref maps, t.customControl6, 24, layers); ExtractSplats(ref maps, t.customControl7, 28, layers); t.terrain.terrainData.SetAlphamaps(0, 0, maps); EditorUtility.SetDirty(t.terrain.terrainData); keywords.DisableKeyword("_CUSTOMSPLATTEXTURES"); MicroSplatShaderGUI.MicroSplatCompiler compiler = new MicroSplatShaderGUI.MicroSplatCompiler(); compiler.Compile(t.templateMaterial); t.customControl0 = null; t.customControl1 = null; t.customControl2 = null; t.customControl3 = null; t.customControl4 = null; t.customControl5 = null; t.customControl6 = null; t.customControl7 = null; EditorUtility.SetDirty(t); MicroSplatTerrain.SyncAll(); } }
public override void DrawFeatureGUI(MicroSplatKeywords keywords) { grassMap = EditorGUILayout.Toggle(CShaderGrassMap, grassMap); shadowMap = EditorGUILayout.Toggle(CShaderShadowMap, shadowMap); if (shadowMap) { EditorGUI.indentLevel++; shadowTapCount = (ShadowTapCount)EditorGUILayout.EnumPopup(CShaderTapCount, shadowTapCount); EditorGUI.indentLevel--; } }
public override void DrawFeatureGUI(MicroSplatKeywords keywords) { clusterMode = (ClusterMode)EditorGUILayout.EnumPopup(CShaderClusters, clusterMode); if (clusterMode != ClusterMode.None && clusterMode != ClusterMode.Stochastic) { EditorGUI.indentLevel++; clusterNoiseUV = (ClusterNoiseUV)EditorGUILayout.EnumPopup(CClusterNoiseUVs, clusterNoiseUV); secondNoise = EditorGUILayout.Toggle(CClusterNoise2, secondNoise); EditorGUI.indentLevel--; } }
public override void DrawPerTextureGUI(int index, MicroSplatKeywords keywords, Material mat, MicroSplatPropData propData) { if (windParticulate != ParticulateMode.None) { perTexParticulate = DrawPerTexFloatSlider(index, 7, GetFeatureName(DefineFeature._PERTEXWINDPARTICULATE), keywords, propData, Channel.A, CPTWindParticulateStrength, 0, 1.0f); } if (glitter) { DrawPerTexFloatSliderNoToggle(index, 8, GetFeatureName(DefineFeature._GLITTER), keywords, propData, Channel.G, CPTGlitterStrength, 0, 1.0f); } }
public override void DrawPerTextureGUI(int index, MicroSplatKeywords keywords, Material mat, MicroSplatPropData propData) { if (wetness || streams) { perTexPorosity = DrawPerTexFloatSlider(index, 3, GetFeatureName(DefineFeature._PERTEXPOROSITY), keywords, propData, Channel.B, CPerTexPorosity, 0.0f, 1.0f); } if (streams) { perTexFoam = DrawPerTexFloatSlider(index, 3, GetFeatureName(DefineFeature._PERTEXFOAM), keywords, propData, Channel.A, CPerTexFoam, 0.0f, 2.0f); } }
public override void DrawPerTextureGUI(int index, MicroSplatKeywords keywords, Material mat, MicroSplatPropData propData) { if (isTessellated) { InitPropData(6, propData, new Color(1.0f, 0.0f, 0.0f, 0.5f)); // displace, up, offset perTexDisplace = DrawPerTexFloatSlider(index, 6, GetFeatureName(DefineFeature._PERTEXTESSDISPLACE), keywords, propData, Channel.R, CPerTexDisplace, 0, 2); perTexUpBias = DrawPerTexFloatSlider(index, 6, GetFeatureName(DefineFeature._PERTEXTESSUPBIAS), keywords, propData, Channel.G, CPerTexUpBias, 0, 1); perTexOffset = DrawPerTexFloatSlider(index, 6, GetFeatureName(DefineFeature._PERTEXTESSOFFSET), keywords, propData, Channel.B, CPerTexOffset, -1, 1); perTexMipLevel = DrawPerTexFloatSlider(index, 4, GetFeatureName(DefineFeature._PERTEXTESSMIPLEVEL), keywords, propData, Channel.A, CPerTexMipLevel, 0, 6); perTexShaping = DrawPerTexFloatSlider(index, 14, GetFeatureName(DefineFeature._PERTEXTESSSHAPING), keywords, propData, Channel.A, CPerTexShaping, 0.001f, 0.999f); if (perTexOffset) { EditorGUILayout.BeginHorizontal(); if (GUILayout.Button(CComputeIdeal)) { float h = IdealOffset(mat.GetTexture("_Diffuse") as Texture2DArray, index); propData.SetValue(index, 6, (int)Channel.B, h); AssetDatabase.Refresh(); } if (GUILayout.Button(CComputeIdealAll)) { var ta = mat.GetTexture("_Diffuse") as Texture2DArray; for (int i = 0; i < 16; ++i) { float h = IdealOffset(ta, i); propData.SetValue(i, 6, (int)Channel.B, h); } } EditorGUILayout.EndHorizontal(); } } if (parallax == ParallaxMode.Offset) { perTexParallax = DrawPerTexFloatSlider(index, 6, GetFeatureName(DefineFeature._PERTEXPARALLAX), keywords, propData, Channel.A, CPerTexParallax, 0, 1); } }
public override void DrawPerTextureGUI(int index, MicroSplatKeywords keywords, Material mat, MicroSplatPropData propData) { if (triplanarMode != TriplanarMode.None) { InitPropData(9, propData, new Color(0.0f, 0.5f, 0.0f, 0.0f)); perTexTriplanar = DrawPerTexFloatSlider(index, 9, GetFeatureName(DefineFeature._PERTEXTRIPLANAR), keywords, propData, Channel.R, CPerTexTriplanar, 0, 1); if (triplanarMode == TriplanarMode.HeightBlended) { perTexTriplanarContrast = DrawPerTexFloatSlider(index, 9, GetFeatureName(DefineFeature._PERTEXTRIPLANARCONTRAST), keywords, propData, Channel.G, CPerTexTriplanarContrast, 0.01f, 1); } } }
public override void DrawFeatureGUI(MicroSplatKeywords keywords) { snow = (SnowMode)EditorGUILayout.EnumPopup(CShaderSnow, snow); if (snow != SnowMode.None) { EditorGUI.indentLevel++; useWorldSpaceUV = EditorGUILayout.Toggle(CWorldSpaceUV, useWorldSpaceUV); snowNormalNoise = EditorGUILayout.Toggle(CShaderNormalNoise, snowNormalNoise); snowDistanceResample = EditorGUILayout.Toggle(CShaderSnowDistanceResample, snowDistanceResample); #if __MICROSPLAT_TEXTURECLUSTERS__ snowStochastic = EditorGUILayout.Toggle(CShaderSnowStochastic, snowStochastic); #endif snowRim = EditorGUILayout.Toggle(CSnowRim, snowRim); snowSSS = EditorGUILayout.Toggle(CShaderSnowSSS, snowSSS); snowSparkle = EditorGUILayout.Toggle(CSnowSparkle, snowSparkle); snowMask = EditorGUILayout.Toggle(CSnowMask, snowMask); EditorGUI.indentLevel--; } }
public override void DrawPerTextureGUI(int index, MicroSplatKeywords keywords, Material mat, MicroSplatPropData propData) { if (clusterMode != ClusterMode.None && clusterMode != ClusterMode.Stochastic) { perTexClusterContrast = DrawPerTexFloatSlider(index, 10, GetFeatureName(DefineFeature._PERTEXCLUSTERCONTRAST), keywords, propData, Channel.R, CPerTexClusterContrast, 1.0f, 0.01f); perTexClusterBoost = DrawPerTexFloatSlider(index, 10, GetFeatureName(DefineFeature._PERTEXCLUSTERBOOST), keywords, propData, Channel.G, CPerTextureClusterBoost, 0.5f, 4.0f); } if (clusterMode == ClusterMode.Stochastic) { perTexStochastic = DrawPerTexFloatSlider(index, 9, GetFeatureName(DefineFeature._PERTEXSTOCHASTIC), keywords, propData, Channel.B, CPerTexStochastic, 0.0f, 1.0f); perTexClusterContrast = DrawPerTexFloatSlider(index, 10, GetFeatureName(DefineFeature._PERTEXCLUSTERCONTRAST), keywords, propData, Channel.R, CPerTexClusterContrast, 0.01f, 1.0f); } }
public void RevisionFromMat() { #if UNITY_EDITOR if (keywordSO == null && templateMaterial != null) { var path = UnityEditor.AssetDatabase.GetAssetPath(templateMaterial); path = path.Replace(".mat", "_keywords.asset"); keywordSO = UnityEditor.AssetDatabase.LoadAssetAtPath <MicroSplatKeywords>(path); if (keywordSO == null) { keywordSO = ScriptableObject.CreateInstance <MicroSplatKeywords>(); keywordSO.keywords = new List <string>(templateMaterial.shaderKeywords); UnityEditor.AssetDatabase.CreateAsset(keywordSO, path); UnityEditor.AssetDatabase.SaveAssets(); templateMaterial.shaderKeywords = null; } UnityEditor.EditorUtility.SetDirty(this); } #endif }
public override void DrawFeatureGUI(MicroSplatKeywords keywords) { bool isSurfaceShader = keywords.IsKeywordEnabled("_MSRENDERLOOP_SURFACESHADER"); packMode = (TextureArrayConfig.PackingMode)EditorGUILayout.EnumPopup(CPackMode, packMode); perfMode = (PerformanceMode)EditorGUILayout.EnumPopup(CShaderPerfMode, perfMode); maxTextureCount = (MaxTextureCount)EditorGUILayout.EnumPopup(CMaxTexCount, maxTextureCount); if (isSurfaceShader) { lightingMode = (LightingMode)EditorGUILayout.EnumPopup(CLightingMode, lightingMode); } uvMode = (UVMode)EditorGUILayout.EnumPopup(CUVMode, uvMode); shaderModel = (ShaderModel)EditorGUILayout.EnumPopup(CForceShaderModel, shaderModel); samplerMode = (SamplerMode)EditorGUILayout.EnumPopup(CSamplerMode, samplerMode); emissiveArray = EditorGUILayout.Toggle(CEmissiveArray, emissiveArray); perPixelNormal = EditorGUILayout.Toggle(CPerPixelNormal, perPixelNormal); disableHeightBlend = EditorGUILayout.Toggle(CDisableHeightBlend, disableHeightBlend); disableNormals = EditorGUILayout.Toggle(CDisableNormals, disableNormals); useCustomSplatMaps = EditorGUILayout.Toggle(CUseCustomSplatMaps, useCustomSplatMaps); debugOutput = (DebugOutput)EditorGUILayout.EnumPopup("Debug", debugOutput); }