private static void SetupMicroSplatMaterial(DiggerSystem diggerSystem)
{
var microSplat = diggerSystem.Terrain.GetComponent <MicroSplatTerrain>();
if (!microSplat)
{
Debug.LogError($"Could not find MicroSplatTerrain on terrain {diggerSystem.Terrain.name}");
return;
}
var microSplatShader = MicroSplatUtilities.GetDiggerShader(microSplat);
if (microSplatShader == null)
{
Debug.LogError($"Could not find MicroSplat Digger shader");
return;
}
var material = new Material(microSplatShader);
material.CopyPropertiesFromMaterial(microSplat.matInstance);
var matPath = Path.Combine(diggerSystem.BasePathData, $"diggerMicroSplat.mat");
material = EditorUtils.CreateOrReplaceAsset(material, matPath);
AssetDatabase.ImportAsset(matPath, ImportAssetOptions.ForceUpdate);
diggerSystem.Materials[0] = material;
}
private static void SetupURPTerrainMaterial(DiggerSystem diggerSystem, bool forceRefresh)
{
var terrainAlreadyHasDiggerMaterial = diggerSystem.Terrain.materialTemplate &&
diggerSystem.Terrain.materialTemplate.shader.name == "Digger/URP/Terrain/Lit";
if (forceRefresh || !terrainAlreadyHasDiggerMaterial)
{
var terrainMaterial = new Material(Shader.Find("Digger/URP/Terrain/Lit"));
terrainMaterial.SetFloat(TerrainWidthInvProperty, 1f / diggerSystem.Terrain.terrainData.size.x);
terrainMaterial.SetFloat(TerrainHeightInvProperty, 1f / diggerSystem.Terrain.terrainData.size.z);
if (diggerSystem.Terrain.materialTemplate && diggerSystem.Terrain.materialTemplate.IsKeywordEnabled("_TERRAIN_BLEND_HEIGHT"))
{
terrainMaterial.EnableKeyword("_TERRAIN_BLEND_HEIGHT");
terrainMaterial.SetFloat(EnableHeightBlend, 1);
}
else
{
terrainMaterial.DisableKeyword("_TERRAIN_BLEND_HEIGHT");
terrainMaterial.SetFloat(EnableHeightBlend, 0);
}
if (diggerSystem.Terrain.materialTemplate && diggerSystem.Terrain.materialTemplate.IsKeywordEnabled("ENABLE_TERRAIN_PERPIXEL_NORMAL"))
{
terrainMaterial.EnableKeyword("ENABLE_TERRAIN_PERPIXEL_NORMAL");
terrainMaterial.SetFloat(EnableInstancedPerPixelNormal, 1);
}
else
{
terrainMaterial.DisableKeyword("ENABLE_TERRAIN_PERPIXEL_NORMAL");
terrainMaterial.SetFloat(EnableInstancedPerPixelNormal, 0);
}
if (diggerSystem.Terrain.materialTemplate)
{
terrainMaterial.SetFloat(HeightTransition, diggerSystem.Terrain.materialTemplate.GetFloat(HeightTransition));
}
terrainMaterial = EditorUtils.CreateOrReplaceAsset(terrainMaterial,
Path.Combine(diggerSystem.BasePathData, "terrainMaterial.mat"));
diggerSystem.Terrain.materialTemplate = terrainMaterial;
}
if (diggerSystem.Terrain.materialTemplate.shader.name != "Digger/URP/Terrain/Lit")
{
Debug.LogWarning("Looks like terrain material doesn't match cave meshes material.");
}
if (!terrainAlreadyHasDiggerMaterial)
{
EditorUtility.DisplayDialog("URP Version 10.2+",
"If you use URP v10.2+ you must import the latest version of Digger URP shaders in Assets/Digger/Shaders folder. " +
"Just double-click on DiggerURP10.unitypackage file.",
"Ok");
}
}
private static void SetupHDRPMaterial(DiggerSystem diggerSystem, List <Texture2D> textures)
{
var material = new Material(Shader.Find("Digger/HDRP/Mesh/Lit"));
var tData = diggerSystem.Terrain.terrainData;
if (tData.terrainLayers.Length > 4)
{
material.EnableKeyword("_TERRAIN_8_LAYERS");
}
var enableMaskMap = false;
for (var i = 0; i < tData.terrainLayers.Length && i < 8; i++)
{
var terrainLayer = tData.terrainLayers[i];
if (terrainLayer == null || terrainLayer.diffuseTexture == null)
{
continue;
}
if (terrainLayer.maskMapTexture)
{
enableMaskMap = true;
}
material.SetFloat($"_NormalScale{i}", terrainLayer.normalScale);
material.SetVector($"_MaskMapRemapOffset{i}", Vector4.zero);
material.SetVector($"_MaskMapRemapScale{i}", Vector4.one);
material.SetVector($"_DiffuseRemapScale{i}", Vector4.one);
material.SetFloat($"_LayerHasMask{i}", terrainLayer.maskMapTexture ? 1f : 0f);
material.SetFloat($"_Metallic{i}", terrainLayer.metallic);
material.SetFloat($"_Smoothness{i}", terrainLayer.smoothness);
material.SetTexture(SplatPrefixProperty + i, terrainLayer.diffuseTexture);
material.SetTexture(NormalPrefixProperty + i, terrainLayer.normalMapTexture);
material.SetTexture(MaskPrefixProperty + i, terrainLayer.maskMapTexture);
material.SetTextureScale(SplatPrefixProperty + i,
new Vector2(1f / terrainLayer.tileSize.x, 1f / terrainLayer.tileSize.y));
material.SetTextureOffset(SplatPrefixProperty + i, terrainLayer.tileOffset);
textures.Add(terrainLayer.diffuseTexture);
}
if (enableMaskMap)
{
material.EnableKeyword("_MASKMAP");
}
var matPath = Path.Combine(diggerSystem.BasePathData, $"meshMaterialPass.mat");
material = EditorUtils.CreateOrReplaceAsset(material, matPath);
AssetDatabase.ImportAsset(matPath, ImportAssetOptions.ForceUpdate);
diggerSystem.Materials[0] = material;
}
private void Sync(Material m)
{
// Check itself hasn't been destroyed
if (!this)
{
return;
}
var digger = GetComponent <DiggerSystem>();
if (!digger || digger.Materials == null || digger.Materials.Length == 0 || !digger.Materials[0])
{
Debug.LogWarning($"[Digger] Could not sync MicroSplat material");
return;
}
var microSplat = digger.Terrain.GetComponent <MicroSplatTerrain>();
if (!microSplat)
{
Debug.LogError($"Could not find MicroSplatTerrain on terrain {digger.Terrain.name}");
return;
}
if (!microSplat.matInstance)
{
Debug.Log($"[Digger] Skipping sync of MicroSplat material");
return;
}
var material = digger.Materials[0];
material.CopyPropertiesFromMaterial(microSplat.matInstance);
#if UNITY_EDITOR
if (!Application.isPlaying)
{
var matPath = Path.Combine(digger.BasePathData, $"diggerMicroSplat.mat");
material = EditorUtils.CreateOrReplaceAsset(material, matPath);
AssetDatabase.ImportAsset(matPath, ImportAssetOptions.ForceUpdate);
}
#endif
digger.Materials[0] = material;
}
private static void SetupHDRPTerrainMaterial(DiggerSystem diggerSystem, bool forceRefresh)
{
if (forceRefresh || !diggerSystem.Terrain.materialTemplate ||
diggerSystem.Terrain.materialTemplate.shader.name != "Digger/HDRP/Terrain/Lit")
{
var terrainMaterial = new Material(Shader.Find("Digger/HDRP/Terrain/Lit"));
terrainMaterial = EditorUtils.CreateOrReplaceAsset(terrainMaterial,
Path.Combine(diggerSystem.BasePathData, "terrainMaterial.mat"));
terrainMaterial.SetFloat(TerrainWidthInvProperty, 1f / diggerSystem.Terrain.terrainData.size.x);
terrainMaterial.SetFloat(TerrainHeightInvProperty, 1f / diggerSystem.Terrain.terrainData.size.z);
diggerSystem.Terrain.materialTemplate = terrainMaterial;
}
if (diggerSystem.Terrain.materialTemplate.shader.name != "Digger/HDRP/Terrain/Lit")
{
Debug.LogWarning("Looks like terrain material doesn't match cave meshes material.");
}
}
private static void SetupStandardTerrainMaterial(DiggerSystem diggerSystem, bool forceRefresh)
{
if (forceRefresh || !diggerSystem.Terrain.materialTemplate ||
diggerSystem.Terrain.materialTemplate.shader.name != "Nature/Terrain/Digger/Cuttable-Triplanar")
{
#if !UNITY_2019_2_OR_NEWER
diggerSystem.Terrain.materialType = Terrain.MaterialType.Custom;
#endif
var terrainMaterial = new Material(Shader.Find("Nature/Terrain/Digger/Cuttable-Triplanar"));
terrainMaterial = EditorUtils.CreateOrReplaceAsset(terrainMaterial,
Path.Combine(diggerSystem.BasePathData, "terrainMaterial.mat"));
terrainMaterial.SetFloat(TerrainWidthInvProperty, 1f / diggerSystem.Terrain.terrainData.size.x);
terrainMaterial.SetFloat(TerrainHeightInvProperty, 1f / diggerSystem.Terrain.terrainData.size.z);
diggerSystem.Terrain.materialTemplate = terrainMaterial;
}
if (diggerSystem.Terrain.materialTemplate.shader.name != "Nature/Terrain/Digger/Cuttable-Triplanar")
{
Debug.LogWarning("Looks like terrain material doesn't match cave meshes material.");
}
}
private static void SetupLWRPMaterial(int pass, DiggerSystem diggerSystem, List <Texture2D> textures)
{
var material = diggerSystem.Materials[pass];
var expectedShaderName = $"Digger/LWRP/Mesh-Pass{pass}";
if (!material || material.shader.name != expectedShaderName)
{
material = new Material(Shader.Find(expectedShaderName));
}
var tData = diggerSystem.Terrain.terrainData;
var offset = pass * TxtCountPerPass;
for (var i = 0; i + offset < tData.terrainLayers.Length && i < TxtCountPerPass; i++)
{
var terrainLayer = tData.terrainLayers[i + offset];
if (terrainLayer == null || terrainLayer.diffuseTexture == null)
{
continue;
}
material.SetFloat($"_tiles{i}x", 1.0f / terrainLayer.tileSize.x);
material.SetFloat($"_tiles{i}y", 1.0f / terrainLayer.tileSize.y);
material.SetFloat($"_offset{i}x", terrainLayer.tileOffset.x);
material.SetFloat($"_offset{i}y", terrainLayer.tileOffset.y);
material.SetFloat($"_normalScale{i}", terrainLayer.normalScale);
material.SetFloat($"_Metallic{i}", terrainLayer.metallic);
material.SetFloat($"_Smoothness{i}", terrainLayer.smoothness);
material.SetTexture(SplatPrefixProperty + i, terrainLayer.diffuseTexture);
material.SetTexture(NormalPrefixProperty + i, terrainLayer.normalMapTexture);
textures.Add(terrainLayer.diffuseTexture);
}
var matPath = Path.Combine(diggerSystem.BasePathData, $"meshMaterialPass{pass}.mat");
material = EditorUtils.CreateOrReplaceAsset(material, matPath);
AssetDatabase.ImportAsset(matPath, ImportAssetOptions.ForceUpdate);
diggerSystem.Materials[pass] = material;
}
private static void SetupCTSAdvancedTessMaterial(DiggerSystem diggerSystem)
{
if (!diggerSystem.Materials[0] ||
diggerSystem.Materials[0].shader.name != "CTS/CTS Terrain Shader Advanced Tess Mesh")
{
diggerSystem.Materials[0] = new Material(Shader.Find("CTS/CTS Terrain Shader Advanced Tess Mesh"));
}
if (!diggerSystem.Terrain.materialTemplate ||
!diggerSystem.Terrain.materialTemplate.shader.name.StartsWith("CTS/CTS Terrain Shader Advanced Tess"))
{
Debug.LogWarning($"Looks like terrain material doesn\'t match cave meshes material. " +
$"Expected \'CTS/CTS Terrain Shader Advanced Tess CutOut\', was {diggerSystem.Terrain.materialTemplate.shader.name}. " +
$"Please fix this by assigning the right material to the terrain.");
return;
}
diggerSystem.Materials[0].CopyPropertiesFromMaterial(diggerSystem.Terrain.materialTemplate);
var matPath = Path.Combine(diggerSystem.BasePathData, "meshMaterial.mat");
diggerSystem.Materials[0] = EditorUtils.CreateOrReplaceAsset(diggerSystem.Materials[0], matPath);
AssetDatabase.ImportAsset(matPath, ImportAssetOptions.ForceUpdate);
}
private static void SetupURPMaterial(int pass, DiggerSystem diggerSystem, List <Texture2D> textures)
{
var material = diggerSystem.Materials[pass];
var expectedShaderName = $"Digger/URP/Mesh-Pass{pass}";
if (!material || material.shader.name != expectedShaderName)
{
material = new Material(Shader.Find(expectedShaderName));
}
var tData = diggerSystem.Terrain.terrainData;
if (tData.terrainLayers.Length <= 4 && diggerSystem.Terrain.materialTemplate.IsKeywordEnabled("_TERRAIN_BLEND_HEIGHT"))
{
material.EnableKeyword("_TERRAIN_BLEND_HEIGHT");
material.SetFloat(EnableHeightBlend, 1);
material.SetFloat(HeightTransition, diggerSystem.Terrain.materialTemplate.GetFloat("_HeightTransition"));
}
else
{
material.DisableKeyword("_TERRAIN_BLEND_HEIGHT");
material.SetFloat(EnableHeightBlend, 0);
}
var normalmap = false;
var maskmap = false;
var offset = pass * TxtCountPerPass;
for (var i = 0; i + offset < tData.terrainLayers.Length && i < TxtCountPerPass; i++)
{
var terrainLayer = tData.terrainLayers[i + offset];
if (terrainLayer == null || terrainLayer.diffuseTexture == null)
{
continue;
}
if (terrainLayer.normalMapTexture)
{
normalmap = true;
}
if (terrainLayer.maskMapTexture)
{
maskmap = true;
}
var importer = (TextureImporter)TextureImporter.GetAtPath(AssetDatabase.GetAssetPath(terrainLayer.diffuseTexture));
material.SetFloat($"_NumLayersCount", tData.terrainLayers.Length);
material.SetFloat($"_NormalScale{i}", terrainLayer.normalScale);
material.SetFloat($"_Metallic{i}", terrainLayer.metallic);
material.SetFloat($"_Smoothness{i}", importer && importer.DoesSourceTextureHaveAlpha() ? 1 : terrainLayer.smoothness);
material.SetFloat($"_LayerHasMask{i}", terrainLayer.maskMapTexture ? 1 : 0);
material.SetVector($"_DiffuseRemapScale{i}", terrainLayer.diffuseRemapMax - terrainLayer.diffuseRemapMin);
material.SetVector($"_MaskMapRemapScale{i}", terrainLayer.maskMapRemapMax);
material.SetVector($"_MaskMapRemapOffset{i}", terrainLayer.maskMapRemapMin);
material.SetTexture(SplatPrefixProperty + i, terrainLayer.diffuseTexture);
material.SetTexture(NormalPrefixProperty + i, terrainLayer.normalMapTexture);
material.SetTexture(MaskPrefixProperty + i, terrainLayer.maskMapTexture);
material.SetTextureScale(SplatPrefixProperty + i,
new Vector2(1f / terrainLayer.tileSize.x, 1f / terrainLayer.tileSize.y));
material.SetTextureOffset(SplatPrefixProperty + i, terrainLayer.tileOffset);
textures.Add(terrainLayer.diffuseTexture);
}
if (normalmap)
{
material.EnableKeyword("_NORMALMAP");
}
else
{
material.DisableKeyword("_NORMALMAP");
}
if (maskmap)
{
material.EnableKeyword("_MASKMAP");
}
else
{
material.DisableKeyword("_MASKMAP");
}
var matPath = Path.Combine(diggerSystem.BasePathData, $"meshMaterialPass{pass}.mat");
material = EditorUtils.CreateOrReplaceAsset(material, matPath);
AssetDatabase.ImportAsset(matPath, ImportAssetOptions.ForceUpdate);
diggerSystem.Materials[pass] = material;
}
