protected virtual void MaterialTesselationPropertiesGUI() { // Display tessellation option if it exist if (tessellationMode != null) { using (var header = new HeaderScope(StylesBaseLit.tessellationText.text, (uint)Expandable.Tesselation, this)) { if (header.expanded) { TessellationModePopup(); m_MaterialEditor.ShaderProperty(tessellationFactor, StylesBaseLit.tessellationFactorText); DrawDelayedFloatProperty(tessellationFactorMinDistance, StylesBaseLit.tessellationFactorMinDistanceText); DrawDelayedFloatProperty(tessellationFactorMaxDistance, StylesBaseLit.tessellationFactorMaxDistanceText); // clamp min distance to be below max distance tessellationFactorMinDistance.floatValue = Math.Min(tessellationFactorMaxDistance.floatValue, tessellationFactorMinDistance.floatValue); m_MaterialEditor.ShaderProperty(tessellationFactorTriangleSize, StylesBaseLit.tessellationFactorTriangleSizeText); if ((TessellationMode)tessellationMode.floatValue == TessellationMode.Phong) { m_MaterialEditor.ShaderProperty(tessellationShapeFactor, StylesBaseLit.tessellationShapeFactorText); } if (doubleSidedEnable.floatValue == 0.0) { m_MaterialEditor.ShaderProperty(tessellationBackFaceCullEpsilon, StylesBaseLit.tessellationBackFaceCullEpsilonText); } } } } }
protected override void MaterialPropertiesGUI(Material material) { // Don't draw the header if we have empty content if (enableHeightBlend == null && enableInstancedPerPixelNormal == null && customProperties.Count == 0) { return; } using (var header = new HeaderScope(styles.terrainText, (uint)Expandable.Other, this)) { if (header.expanded) { if (enableHeightBlend != null) { m_MaterialEditor.ShaderProperty(enableHeightBlend, styles.enableHeightBlend); if (enableHeightBlend.floatValue > 0) { EditorGUI.indentLevel++; m_MaterialEditor.ShaderProperty(heightTransition, styles.heightTransition); EditorGUI.indentLevel--; } } if (enableInstancedPerPixelNormal != null) { EditorGUI.BeginDisabledGroup(!m_MaterialEditor.IsInstancingEnabled()); m_MaterialEditor.ShaderProperty(enableInstancedPerPixelNormal, styles.enableInstancedPerPixelNormal); EditorGUI.EndDisabledGroup(); } foreach (var prop in customProperties) { m_MaterialEditor.ShaderProperty(prop, prop.displayName); } } } }
//override for adding Tesselation public override void ShaderPropertiesGUI(Material material) { // Use default labelWidth EditorGUIUtility.labelWidth = 0f; // Detect any changes to the material EditorGUI.BeginChangeCheck(); { using (var header = new HeaderScope(StylesBaseUnlit.optionText, (uint)Expendable.Base, this)) { if (header.expended) BaseMaterialPropertiesGUI(); } MaterialTesselationPropertiesGUI(); VertexAnimationPropertiesGUI(); FpsModePropertiesGUI(); MaterialPropertiesGUI(material); DoEmissionArea(material); using (var header = new HeaderScope(StylesBaseUnlit.advancedText, (uint)Expendable.Advance, this)) { if (header.expended) { m_MaterialEditor.EnableInstancingField(); MaterialPropertiesAdvanceGUI(material); } } } if (EditorGUI.EndChangeCheck()) { foreach (var obj in m_MaterialEditor.targets) SetupMaterialKeywordsAndPassInternal((Material)obj); } }
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props) { m_MaterialEditor = materialEditor; FindMaterialProperties(props); // Copy/Paste of public void PropertiesDefaultGUI(MaterialProperty[] props) in MaterialEditor.cs to allow to customize inspector for // decal. We don't want to display GI option or instancing option and want to add tooltips to our parameters. m_MaterialEditor.SetDefaultGUIWidths(); using (var header = new HeaderScope(Styles.InputsText, (uint)Expandable.Input, this)) { if (header.expanded) { // We do "- 2" as we always have draw order and decal mesh bias. Update this number if we change the number of mandatory parameters for (var i = 0; i < props.Length - 2; i++) { if ((props[i].flags & (MaterialProperty.PropFlags.HideInInspector | MaterialProperty.PropFlags.PerRendererData)) != 0) { continue; } float h = m_MaterialEditor.GetPropertyHeight(props[i], props[i].displayName); Rect r = EditorGUILayout.GetControlRect(true, h, EditorStyles.layerMaskField); m_MaterialEditor.ShaderProperty(r, props[i], props[i].displayName); } } } ShaderPropertiesGUI(); // We should always do this call at the end m_MaterialEditor.serializedObject.ApplyModifiedProperties(); }
protected void EmissiveInputGUI(Material material) { using (var header = new HeaderScope(Styles.emissiveLabelText, (uint)Expendable.Emissive, this)) { if (header.expended) { m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor); if (material.GetTexture(kEmissiveColorMap)) { EditorGUI.indentLevel++; m_MaterialEditor.ShaderProperty(UVEmissive, Styles.UVMappingEmissiveText); UVBaseMapping uvEmissiveMapping = (UVBaseMapping)UVEmissive.floatValue; float X, Y, Z, W; X = (uvEmissiveMapping == UVBaseMapping.UV0) ? 1.0f : 0.0f; Y = (uvEmissiveMapping == UVBaseMapping.UV1) ? 1.0f : 0.0f; Z = (uvEmissiveMapping == UVBaseMapping.UV2) ? 1.0f : 0.0f; W = (uvEmissiveMapping == UVBaseMapping.UV3) ? 1.0f : 0.0f; UVMappingMaskEmissive.colorValue = new Color(X, Y, Z, W); m_MaterialEditor.TextureScaleOffsetProperty(emissiveColorMap); EditorGUI.indentLevel--; } } } }
protected override void VertexAnimationPropertiesGUI() { using (var header = new HeaderScope(StylesBaseLit.vertexAnimation, (uint)Expandable.VertexAnimation, this)) { if (header.expanded) { if (windEnable != null) { // Hide wind option. Wind is deprecated and will be remove in the future. Use shader graph instead /* * m_MaterialEditor.ShaderProperty(windEnable, StylesBaseLit.windText); * if (!windEnable.hasMixedValue && windEnable.floatValue > 0.0f) * { * EditorGUI.indentLevel++; * m_MaterialEditor.ShaderProperty(windInitialBend, StylesBaseLit.windInitialBendText); * m_MaterialEditor.ShaderProperty(windStiffness, StylesBaseLit.windStiffnessText); * m_MaterialEditor.ShaderProperty(windDrag, StylesBaseLit.windDragText); * m_MaterialEditor.ShaderProperty(windShiverDrag, StylesBaseLit.windShiverDragText); * m_MaterialEditor.ShaderProperty(windShiverDirectionality, StylesBaseLit.windShiverDirectionalityText); * EditorGUI.indentLevel--; * } */ } if (enableMotionVectorForVertexAnimation != null) { m_MaterialEditor.ShaderProperty(enableMotionVectorForVertexAnimation, StylesBaseUnlit.enableMotionVectorForVertexAnimationText); } } } }
void DrawLayeringOptions(bool mainLayerInfluenceEnable, uint expended, int layerIndex) { // do layering option (if main layer (0) check if there is any content before drawing the foldout) if (layerIndex > 0 || layerIndex == 0 && !useMainLayerInfluence.hasMixedValue && useMainLayerInfluence.floatValue != 0.0f) { using (var header = new HeaderScope(styles.layeringOptionText.text, expended, this, colorDot: s_Styles.layerColors[layerIndex], subHeader: true)) { if (header.expanded) { // Main layer does not have any options but height base blend. if (layerIndex > 0) { m_MaterialEditor.ShaderProperty(opacityAsDensity[layerIndex], styles.opacityAsDensityText); if (mainLayerInfluenceEnable) { m_MaterialEditor.ShaderProperty(inheritBaseColor[layerIndex - 1], styles.inheritBaseColorText); m_MaterialEditor.ShaderProperty(inheritBaseNormal[layerIndex - 1], styles.inheritBaseNormalText); // Main height influence is only available if the shader use the heightmap for displacement (per vertex or per level) // We always display it as it can be tricky to know when per pixel displacement is enabled or not m_MaterialEditor.ShaderProperty(inheritBaseHeight[layerIndex - 1], styles.inheritBaseHeightText); } } else { m_MaterialEditor.TexturePropertySingleLine(styles.layerInfluenceMapMaskText, layerInfluenceMaskMap); } } } } }
protected override void MaterialPropertiesGUI(Material material) { using (var header = new HeaderScope(Styles.InputsText, (uint)Expandable.Input, this)) { if (header.expanded) { m_MaterialEditor.TexturePropertySingleLine(Styles.colorText, colorMap, color); m_MaterialEditor.TextureScaleOffsetProperty(colorMap); } } var surfaceTypeValue = (SurfaceType)surfaceType.floatValue; if (surfaceTypeValue == SurfaceType.Transparent) { using (var header = new HeaderScope(StylesBaseUnlit.TransparencyInputsText, (uint)Expandable.Transparency, this)) { if (header.expanded) { DoDistortionInputsGUI(); } } } using (var header = new HeaderScope(Styles.emissiveLabelText, (uint)Expandable.Emissive, this)) { if (header.expanded) { m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor); m_MaterialEditor.TextureScaleOffsetProperty(emissiveColorMap); DoEmissionArea(material); } } }
protected void BaseInputGUI(Material material) { using (var header = new HeaderScope(Styles.InputsText, (uint)Expendable.Input, this)) { if (header.expended) { // The base color map and matching base color value m_MaterialEditor.TexturePropertySingleLine(Styles.baseColorText, baseColorMap, baseColor); // If no mask texture was provided, we display the smoothness value if (maskMap.textureValue == null) { m_MaterialEditor.ShaderProperty(smoothness, Styles.smoothnessText); } // If we have a mask map, we do not use values but remapping fields instead m_MaterialEditor.TexturePropertySingleLine(Styles.maskMapSpecularText, maskMap); if (maskMap.textureValue != null) { float remapMin = smoothnessRemapMin.floatValue; float remapMax = smoothnessRemapMax.floatValue; EditorGUI.BeginChangeCheck(); EditorGUILayout.MinMaxSlider(Styles.smoothnessRemappingText, ref remapMin, ref remapMax, 0.0f, 1.0f); if (EditorGUI.EndChangeCheck()) { smoothnessRemapMin.floatValue = remapMin; smoothnessRemapMax.floatValue = remapMax; } float aoMin = aoRemapMin.floatValue; float aoMax = aoRemapMax.floatValue; EditorGUI.BeginChangeCheck(); EditorGUILayout.MinMaxSlider(Styles.aoRemappingText, ref aoMin, ref aoMax, 0.0f, 1.0f); if (EditorGUI.EndChangeCheck()) { aoRemapMin.floatValue = aoMin; aoRemapMax.floatValue = aoMax; } } // The specular color value (that affects the color of the specular lighting term) m_MaterialEditor.ShaderProperty(specularColor, Styles.specularColorText); // The primal normal map field m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap, normalScale); // m_MaterialEditor.TexturePropertySingleLine(Styles.bentNormalMapText, bentNormalMap); // The diffusion/transmission/subsurface gui ShaderSSSAndTransmissionInputGUI(material); // Anisotropy GUI ShaderAnisoInputGUI(material); // Define the UV mapping for the base textures BaseUVMappingInputGUI(); } } }
public void ShaderPropertiesGUI() { using (var header = new HeaderScope(Styles.SortingText, (uint)Expandable.Sorting, this)) { if (header.expanded) { m_MaterialEditor.ShaderProperty(drawOrder, Styles.drawOrderText); m_MaterialEditor.ShaderProperty(decalMeshDepthBias, Styles.meshDecalDepthBiasText); } } }
protected override void MaterialPropertiesGUI(Material material) { //if (GUILayout.Button("Generate All Properties")) //{ // Debug.Log(_materialProperties.ToShaderPropertiesStringInternal()); //} using (var header = new HeaderScope(StylesStackLit.stackOptionText, (uint)Expandable.Input, this, spaceAtEnd: false)) { if (header.expanded) { _materialProperties.OnGUI(); } } }
bool DoMaterialReferencesGUI(AssetImporter materialImporter) { bool layersChanged = false; using (var header = new HeaderScope(styles.materialReferencesText.text, (uint)LayerExpendable.MaterialReferences, this)) { if (header.expended) { Material material = m_MaterialEditor.target as Material; Color originalContentColor = GUI.contentColor; for (int layerIndex = 0; layerIndex < numLayer; ++layerIndex) { EditorGUI.BeginChangeCheck(); GUI.contentColor = styles.layerColors[layerIndex]; m_MaterialLayers[layerIndex] = EditorGUILayout.ObjectField(styles.layerLabels[layerIndex], m_MaterialLayers[layerIndex], typeof(Material), true) as Material; if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(materialImporter, "Change layer material"); SynchronizeLayerProperties(material, m_MaterialLayers, layerIndex, true); layersChanged = true; } GUI.contentColor = originalContentColor; GUILayout.BeginHorizontal(); { GUILayout.FlexibleSpace(); if (GUILayout.Button(styles.syncAllButUVButtonText)) { SynchronizeLayerProperties(material, m_MaterialLayers, layerIndex, true); layersChanged = true; } if (GUILayout.Button(styles.syncAllButtonText)) { SynchronizeLayerProperties(material, m_MaterialLayers, layerIndex, false); layersChanged = true; } } GUILayout.EndHorizontal(); } } } return(layersChanged); }
protected void DetailsInput(Material material) { using (var header = new HeaderScope(Styles.threadText, (uint)Expendable.Detail, this)) { if (header.expended) { m_MaterialEditor.TexturePropertySingleLine(Styles.threadMapText, threadMap); if (material.GetTexture(kThreadMap)) { EditorGUI.indentLevel++; m_MaterialEditor.ShaderProperty(threadAOScale, Styles.threadAOScaleText); m_MaterialEditor.ShaderProperty(threadNormalScale, Styles.threadNormalScaleText); m_MaterialEditor.ShaderProperty(threadSmoothnessScale, Styles.threadSmoothnessScaleText); EditorGUI.indentLevel--; } m_MaterialEditor.TexturePropertySingleLine(Styles.FuzzDetailText, fuzzDetailMap); if (material.GetTexture(kFuzzDetailMap)) { m_MaterialEditor.ShaderProperty(fuzzDetailScale, Styles.FuzzDetailScale); m_MaterialEditor.ShaderProperty(fuzzDetailUVScale, Styles.FuzzDetailUVScale); } if (material.GetTexture(kThreadMap) || material.GetTexture(kFuzzDetailMap)) { EditorGUI.indentLevel++; m_MaterialEditor.ShaderProperty(UVThread, Styles.UVThreadMappingText); // Setup the UVSet for detail, if planar/triplanar is use for base, it will override the mapping of detail (See shader code) float X, Y, Z, W; X = ((UVThreadMapping)UVThread.floatValue == UVThreadMapping.UV0) ? 1.0f : 0.0f; Y = ((UVThreadMapping)UVThread.floatValue == UVThreadMapping.UV1) ? 1.0f : 0.0f; Z = ((UVThreadMapping)UVThread.floatValue == UVThreadMapping.UV2) ? 1.0f : 0.0f; W = ((UVThreadMapping)UVThread.floatValue == UVThreadMapping.UV3) ? 1.0f : 0.0f; UVMappingMaskThread.colorValue = new Color(X, Y, Z, W); EditorGUI.indentLevel++; m_MaterialEditor.ShaderProperty(linkDetailsWithBase, Styles.linkDetailsWithBaseText); EditorGUI.indentLevel--; m_MaterialEditor.TextureScaleOffsetProperty(threadMap); } } } }
bool DoLayerGUI(AssetImporter materialImporter, int layerIndex) { bool result = false; Array values = Enum.GetValues(typeof(LayerExpandable)); if (layerIndex > 1) //main layer (0) and layer 1 always here { int startShowVal = Array.IndexOf(values, LayerExpandable.ShowLayer1); if (!GetExpandedAreas((uint)values.GetValue(startShowVal + layerIndex))) { return(false); } } Material material = m_MaterialEditor.target as Material; bool mainLayerInfluenceEnable = useMainLayerInfluence.floatValue > 0.0f; int startLayer = Array.IndexOf(values, LayerExpandable.MainLayer); using (var layerHeader = new HeaderScope(s_Styles.layerLabels[layerIndex].text, (uint)values.GetValue(startLayer + layerIndex), this, false, s_Styles.layerColors[layerIndex])) { if (layerHeader.expanded) { //Note LayeringOptionMain do not preced LayeringOption1 int startLayeringOptionValue = Array.IndexOf(values, LayerExpandable.LayeringOption1); var layeringOptionValue = layerIndex == 0 ? LayerExpandable.LayeringOptionMain : (LayerExpandable)values.GetValue(startLayeringOptionValue + layerIndex - 1); DrawLayeringOptions(mainLayerInfluenceEnable, (uint)layeringOptionValue, layerIndex); int startInputValue = Array.IndexOf(values, LayerExpandable.MainInput); var inputValue = (LayerExpandable)values.GetValue(startInputValue + layerIndex); int startDetailValue = Array.IndexOf(values, LayerExpandable.MainDetail); var detailValue = (LayerExpandable)values.GetValue(startDetailValue + layerIndex); DoLayerGUI(material, layerIndex, true, m_UseHeightBasedBlend, (uint)inputValue, (uint)detailValue, colorDot: s_Styles.layerColors[layerIndex], subHeader: true); if (!GetExpandedAreas((uint)detailValue)) { EditorGUILayout.Space(); } } } return(result); }
protected override void MaterialPropertiesGUI(Material material) { using (var header = new HeaderScope(Styles.fabricLabelText, (uint)Expendable.Other, this)) { if (header.expended) { // The generic type of the fabric (either cotton/wool or silk) m_MaterialEditor.ShaderProperty(fabricType, Styles.fabricTypeText); } } // Base GUI BaseInputGUI(material); // Emissive GUI EmissiveInputGUI(material); // Details Input DetailsInput(material); }
bool DoLayerGUI(AssetImporter materialImporter, int layerIndex) { bool result = false; int paramIndex = -1; Array values = Enum.GetValues(typeof(LayerExpandable)); if (layerIndex > 0) { paramIndex = layerIndex - 1; int startShowVal = Array.IndexOf(values, LayerExpandable.ShowLayer1); if (!GetExpandedAreas((uint)values.GetValue(startShowVal + paramIndex))) { return(false); } } //showLayer[layerIndex].floatValue = EditorGUILayout.Foldout(showLayer[layerIndex].floatValue != 0.0f, styles.layerLabels[layerIndex], styles.layerLabelColors[layerIndex]) ? 1.0f : 0.0f; Material material = m_MaterialEditor.target as Material; bool mainLayerInfluenceEnable = useMainLayerInfluence.floatValue > 0.0f; // Main layer does not have any options but height base blend. if (layerIndex > 0) { int startLayeringOptionValue = Array.IndexOf(values, LayerExpandable.LayeringOption1); using (var header = new HeaderScope(s_Styles.layerLabels[layerIndex].text + " " + styles.layeringOptionText.text, (uint)values.GetValue(startLayeringOptionValue + paramIndex), this, colorDot: s_Styles.layerColors[layerIndex])) { if (header.expanded) { m_MaterialEditor.ShaderProperty(opacityAsDensity[layerIndex], styles.opacityAsDensityText); if (mainLayerInfluenceEnable) { m_MaterialEditor.ShaderProperty(inheritBaseColor[paramIndex], styles.inheritBaseColorText); m_MaterialEditor.ShaderProperty(inheritBaseNormal[paramIndex], styles.inheritBaseNormalText); // Main height influence is only available if the shader use the heightmap for displacement (per vertex or per level) // We always display it as it can be tricky to know when per pixel displacement is enabled or not m_MaterialEditor.ShaderProperty(inheritBaseHeight[paramIndex], styles.inheritBaseHeightText); } } } } else if (!useMainLayerInfluence.hasMixedValue && useMainLayerInfluence.floatValue != 0.0f) { using (var header = new HeaderScope(s_Styles.layerLabels[layerIndex].text + " " + styles.layeringOptionText.text, (uint)LayerExpandable.LayeringOptionMain, this, colorDot: s_Styles.layerColors[layerIndex])) { if (header.expanded) { m_MaterialEditor.TexturePropertySingleLine(styles.layerInfluenceMapMaskText, layerInfluenceMaskMap); } } } int startInputValue = Array.IndexOf(values, LayerExpandable.Layer1Input); int startDetailValue = Array.IndexOf(values, LayerExpandable.Layer1Detail); DoLayerGUI(material, layerIndex, true, m_UseHeightBasedBlend, s_Styles.layerLabels[layerIndex].text + " ", (uint)values.GetValue(startInputValue + paramIndex), (uint)values.GetValue(startDetailValue + paramIndex), colorDot: s_Styles.layerColors[layerIndex]); return(result); }
protected override void MaterialPropertiesGUI(Material material) { using (var header = new HeaderScope(Styles.InputsText, (uint)Expandable.Input, this)) { if (header.expanded) { m_MaterialEditor.TexturePropertySingleLine(Styles.colorText, colorMap, color); m_MaterialEditor.TextureScaleOffsetProperty(colorMap); } } var surfaceTypeValue = (SurfaceType)surfaceType.floatValue; if (surfaceTypeValue == SurfaceType.Transparent) { using (var header = new HeaderScope(StylesBaseUnlit.TransparencyInputsText, (uint)Expandable.Transparency, this)) { if (header.expanded) { DoDistortionInputsGUI(); } } } using (var header = new HeaderScope(Styles.emissiveLabelText, (uint)Expandable.Emissive, this)) { if (header.expanded) { EditorGUI.BeginChangeCheck(); m_MaterialEditor.ShaderProperty(useEmissiveIntensity, Styles.useEmissiveIntensityText); bool updateEmissiveColor = EditorGUI.EndChangeCheck(); if (useEmissiveIntensity.floatValue == 0) { EditorGUI.BeginChangeCheck(); DoEmissiveTextureProperty(material, emissiveColor); if (EditorGUI.EndChangeCheck() || updateEmissiveColor) { emissiveColor.colorValue = emissiveColor.colorValue; } EditorGUILayout.HelpBox(Styles.emissiveIntensityFromHDRColorText.text, MessageType.Info, true); } else { EditorGUI.BeginChangeCheck(); { DoEmissiveTextureProperty(material, emissiveColorLDR); emissiveColorLDR.colorValue = NormalizeEmissionColor(ref updateEmissiveColor, emissiveColorLDR.colorValue); using (new EditorGUILayout.HorizontalScope()) { EmissiveIntensityUnit unit = (EmissiveIntensityUnit)emissiveIntensityUnit.floatValue; if (unit == EmissiveIntensityUnit.Luminance) { m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText); } else { float evValue = LightUtils.ConvertLuminanceToEv(emissiveIntensity.floatValue); evValue = EditorGUILayout.FloatField(Styles.emissiveIntensityText, evValue); emissiveIntensity.floatValue = LightUtils.ConvertEvToLuminance(evValue); } emissiveIntensityUnit.floatValue = (float)(EmissiveIntensityUnit)EditorGUILayout.EnumPopup(unit); } } if (EditorGUI.EndChangeCheck() || updateEmissiveColor) { emissiveColor.colorValue = emissiveColorLDR.colorValue * emissiveIntensity.floatValue; } } m_MaterialEditor.ShaderProperty(emissiveExposureWeight, Styles.emissiveExposureWeightText); DoEmissionArea(material); } } }
void DoLayeringInputGUI() { using (var header = new HeaderScope(styles.layersText.text, (uint)Expandable.Input, this)) { if (header.expanded) { EditorGUI.showMixedValue = layerCount.hasMixedValue; EditorGUI.BeginChangeCheck(); int newLayerCount = EditorGUILayout.IntSlider(styles.layerCountText, (int)layerCount.floatValue, 2, 4); if (EditorGUI.EndChangeCheck()) { Material material = m_MaterialEditor.target as Material; Undo.RecordObject(material, "Change layer count"); numLayer = newLayerCount; } m_MaterialEditor.TexturePropertySingleLine(styles.layerMapMaskText, layerMaskMap); EditorGUI.indentLevel++; m_MaterialEditor.ShaderProperty(UVBlendMask, styles.UVBlendMaskText); UVBaseMapping uvBlendMask = (UVBaseMapping)UVBlendMask.floatValue; float X, Y, Z, W; X = (uvBlendMask == UVBaseMapping.UV0) ? 1.0f : 0.0f; Y = (uvBlendMask == UVBaseMapping.UV1) ? 1.0f : 0.0f; Z = (uvBlendMask == UVBaseMapping.UV2) ? 1.0f : 0.0f; W = (uvBlendMask == UVBaseMapping.UV3) ? 1.0f : 0.0f; UVMappingMaskBlendMask.colorValue = new Color(X, Y, Z, W); if (((UVBaseMapping)UVBlendMask.floatValue == UVBaseMapping.Planar) || ((UVBaseMapping)UVBlendMask.floatValue == UVBaseMapping.Triplanar)) { m_MaterialEditor.ShaderProperty(texWorldScaleBlendMask, styles.layerTexWorldScaleText); } m_MaterialEditor.TextureScaleOffsetProperty(layerMaskMap); EditorGUI.indentLevel--; m_MaterialEditor.ShaderProperty(vertexColorMode, styles.vertexColorModeText); EditorGUI.BeginChangeCheck(); EditorGUI.showMixedValue = useMainLayerInfluence.hasMixedValue; bool mainLayerModeInfluenceEnable = EditorGUILayout.Toggle(styles.useMainLayerInfluenceModeText, useMainLayerInfluence.floatValue > 0.0f); if (EditorGUI.EndChangeCheck()) { useMainLayerInfluence.floatValue = mainLayerModeInfluenceEnable ? 1.0f : 0.0f; } EditorGUI.BeginChangeCheck(); EditorGUI.showMixedValue = useHeightBasedBlend.hasMixedValue; m_UseHeightBasedBlend = EditorGUILayout.Toggle(styles.useHeightBasedBlendText, useHeightBasedBlend.floatValue > 0.0f); if (EditorGUI.EndChangeCheck()) { useHeightBasedBlend.floatValue = m_UseHeightBasedBlend ? 1.0f : 0.0f; } if (m_UseHeightBasedBlend) { EditorGUI.indentLevel++; m_MaterialEditor.ShaderProperty(heightTransition, styles.heightTransition); EditorGUI.indentLevel--; } m_MaterialEditor.ShaderProperty(objectScaleAffectTile, mainLayerModeInfluenceEnable ? styles.objectScaleAffectTileText2 : styles.objectScaleAffectTileText); } } }
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props) { FindBaseMaterialProperties(props); FindMaterialProperties(props); m_MaterialEditor = materialEditor; // We should always register the key used to keep collapsable state InitExpandableState(materialEditor); // We should always do this call at the beginning m_MaterialEditor.serializedObject.Update(); //Material material = m_MaterialEditor.target as Material; //AssetImporter materialImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(material.GetInstanceID())); bool optionsChanged = false; EditorGUI.BeginChangeCheck(); { BaseMaterialPropertiesGUI(); if (enableHeightBlend != null) { EditorGUI.indentLevel++; m_MaterialEditor.ShaderProperty(enableHeightBlend, styles.enableHeightBlend); if (enableHeightBlend.floatValue > 0) { EditorGUI.indentLevel++; m_MaterialEditor.ShaderProperty(heightTransition, styles.heightTransition); EditorGUI.indentLevel--; } EditorGUI.indentLevel--; } EditorGUILayout.Space(); } if (EditorGUI.EndChangeCheck()) { optionsChanged = true; } bool enablePerPixelNormalChanged = false; using (var header = new HeaderScope(StylesBaseUnlit.advancedText, (uint)Expandable.Advance, this)) { if (header.expanded) { // NB RenderQueue editor is not shown on purpose: we want to override it based on blend mode m_MaterialEditor.EnableInstancingField(); if (m_MaterialEditor.IsInstancingEnabled()) { EditorGUI.indentLevel++; EditorGUI.BeginChangeCheck(); m_MaterialEditor.ShaderProperty(enableInstancedPerPixelNormal, styles.enableInstancedPerPixelNormal); enablePerPixelNormalChanged = EditorGUI.EndChangeCheck(); EditorGUI.indentLevel--; } } } if (optionsChanged || enablePerPixelNormalChanged) { foreach (var obj in m_MaterialEditor.targets) { SetupMaterialKeywordsAndPassInternal((Material)obj); } } // We should always do this call at the end m_MaterialEditor.serializedObject.ApplyModifiedProperties(); }
bool DoMaterialReferencesGUI(AssetImporter materialImporter) { bool layersChanged = false; using (var header = new HeaderScope(styles.materialReferencesText.text, (uint)LayerExpandable.MaterialReferences, this)) { if (header.expanded) { var width = EditorGUIUtility.labelWidth; EditorGUIUtility.labelWidth = 90; Material material = m_MaterialEditor.target as Material; Color originalContentColor = GUI.contentColor; float indentOffset = EditorGUI.indentLevel * 15f; float colorWidth = 14; float UVWidth = 30; float copyButtonWidth = EditorGUIUtility.singleLineHeight; float endOffset = 5f; Rect headerLineRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight); Rect headerLabelRect = new Rect(headerLineRect.x, headerLineRect.y, EditorGUIUtility.labelWidth - indentOffset, headerLineRect.height); Rect headerUVRect = new Rect(headerLineRect.x + headerLineRect.width - 48 - endOffset, headerLineRect.y, UVWidth + 5, headerLineRect.height); Rect headerMaterialDropRect = new Rect(headerLineRect.x + headerLabelRect.width, headerLineRect.y, headerLineRect.width - headerLabelRect.width - headerUVRect.width, headerLineRect.height); EditorGUI.LabelField(headerLabelRect, styles.layerNameHeader, EditorStyles.centeredGreyMiniLabel); EditorGUI.LabelField(headerMaterialDropRect, styles.materialToCopyHeader, EditorStyles.centeredGreyMiniLabel); EditorGUI.LabelField(headerUVRect, styles.uvHeader, EditorStyles.centeredGreyMiniLabel); for (int layerIndex = 0; layerIndex < numLayer; ++layerIndex) { using (new EditorGUILayout.HorizontalScope()) { EditorGUI.BeginChangeCheck(); Rect lineRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight); Rect colorRect = new Rect(lineRect.x, lineRect.y, colorWidth, lineRect.height); Rect materialRect = new Rect(lineRect.x + colorRect.width, lineRect.y, lineRect.width - UVWidth - colorWidth - copyButtonWidth + endOffset, lineRect.height); Rect uvRect = new Rect(lineRect.x + lineRect.width - copyButtonWidth - UVWidth - endOffset, lineRect.y, UVWidth, lineRect.height); Rect copyRect = new Rect(lineRect.x + lineRect.width - copyButtonWidth - endOffset, lineRect.y, copyButtonWidth, lineRect.height); m_MaterialLayers[layerIndex] = EditorGUI.ObjectField(materialRect, styles.layerLabels[layerIndex], m_MaterialLayers[layerIndex], typeof(Material), true) as Material; if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(materialImporter, "Change layer material"); SynchronizeLayerProperties(material, m_MaterialLayers, layerIndex, true); layersChanged = true; } colorRect.width = 30f; GUI.contentColor = styles.layerColors[layerIndex]; EditorGUI.LabelField(colorRect, "■"); GUI.contentColor = originalContentColor; m_WithUV[layerIndex] = EditorGUI.Toggle(uvRect, m_WithUV[layerIndex]); if (GUI.Button(copyRect, GUIContent.none)) { SynchronizeLayerProperties(material, m_MaterialLayers, layerIndex, !m_WithUV[layerIndex]); layersChanged = true; } //fake the icon with two Console icon //Rect copyRect = GUILayoutUtility.GetLastRect(); copyRect.x -= 16; copyRect.width = 40; EditorGUI.LabelField(copyRect, styles.copyButtonIcon); copyRect.x -= 3; copyRect.y += 3; EditorGUI.LabelField(copyRect, styles.copyButtonIcon); } } EditorGUIUtility.labelWidth = width; } } return(layersChanged); }
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props) { FindBaseMaterialProperties(props); FindMaterialProperties(props); m_MaterialEditor = materialEditor; // We should always register the key used to keep collapsable state InitExpandableState(materialEditor); // We should always do this call at the beginning m_MaterialEditor.serializedObject.Update(); Material material = m_MaterialEditor.target as Material; AssetImporter materialImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(material.GetInstanceID())); InitializeMaterialLayers(materialImporter, ref m_MaterialLayers); bool optionsChanged = false; EditorGUI.BeginChangeCheck(); { using (var header = new HeaderScope(StylesBaseUnlit.optionText, (uint)Expandable.Base, this)) { if (header.expanded) { BaseMaterialPropertiesGUI(); } } MaterialTesselationPropertiesGUI(); VertexAnimationPropertiesGUI(); } if (EditorGUI.EndChangeCheck()) { optionsChanged = true; } // In case of pixel displacement and layered shader, all layers must used the same texture mapping for layer that have a heightmap // (Else the algorithm will not work correctly) if ((DisplacementMode)displacementMode.floatValue == DisplacementMode.Pixel) { float compareValue = -1.0f; bool match = true; if (material.GetTexture(kHeightMap + 0)) { compareValue = UVBase[0].floatValue; } if (material.GetTexture(kHeightMap + 1)) { if (compareValue == -1.0f) { compareValue = UVBase[1].floatValue; } else if (compareValue != UVBase[1].floatValue) { match = false; } } if (material.GetTexture(kHeightMap + 2)) { if (compareValue == -1.0f) { compareValue = UVBase[2].floatValue; } else if (compareValue != UVBase[2].floatValue) { match = false; } } if (material.GetTexture(kHeightMap + 3)) { if (compareValue == -1.0f) { compareValue = UVBase[3].floatValue; } else if (compareValue != UVBase[3].floatValue) { match = false; } } if (!match) { EditorGUILayout.HelpBox(styles.perPixelDisplacementLayersWarning.text, MessageType.Warning); } } bool layerChanged = DoLayersGUI(materialImporter); EditorGUI.BeginChangeCheck(); { DoEmissiveGUI(material); } if (EditorGUI.EndChangeCheck()) { optionsChanged = true; } using (var header = new HeaderScope(StylesBaseUnlit.advancedText, (uint)Expandable.Advance, this)) { if (header.expanded) { // NB RenderQueue editor is not shown on purpose: we want to override it based on blend mode m_MaterialEditor.EnableInstancingField(); m_MaterialEditor.ShaderProperty(enableSpecularOcclusion, Styles.enableSpecularOcclusionText); } } if (layerChanged || optionsChanged) { foreach (var obj in m_MaterialEditor.targets) { SetupMaterialKeywordsAndPassInternal((Material)obj); } // SaveAssetsProcessor the referenced material in the users data SaveMaterialLayers(materialImporter); } // We should always do this call at the end m_MaterialEditor.serializedObject.ApplyModifiedProperties(); }
public void ShaderPropertiesGUI(Material material) { // Use default labelWidth EditorGUIUtility.labelWidth = 0f; float normalBlendSrcValue = normalBlendSrc.floatValue; float maskBlendSrcValue = maskBlendSrc.floatValue; Decal.MaskBlendFlags maskBlendFlags = (Decal.MaskBlendFlags)maskBlendMode.floatValue; HDRenderPipelineAsset hdrp = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset; bool perChannelMask = hdrp.renderPipelineSettings.decalSettings.perChannelMask; using (var header = new HeaderScope(Styles.InputsText, (uint)Expendable.Input, this)) { if (header.expended) { // Detect any changes to the material EditorGUI.BeginChangeCheck(); { m_MaterialEditor.TexturePropertySingleLine((material.GetFloat(kAlbedoMode) == 1.0f) ? Styles.baseColorText : Styles.baseColorText2, baseColorMap, baseColor); // Currently always display Albedo contribution as we have an albedo tint that apply EditorGUI.indentLevel++; m_MaterialEditor.ShaderProperty(albedoMode, Styles.AlbedoModeText); EditorGUI.indentLevel--; m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap); if (material.GetTexture(kNormalMap)) { EditorGUI.indentLevel++; normalBlendSrcValue = EditorGUILayout.Popup("Normal Opacity channel", (int)normalBlendSrcValue, blendSourceNames); EditorGUI.indentLevel--; } m_MaterialEditor.TexturePropertySingleLine(Styles.maskMapText[(int)maskBlendFlags], maskMap); if (material.GetTexture(kMaskMap)) { EditorGUI.indentLevel++; maskBlendSrcValue = EditorGUILayout.Popup("Mask Opacity channel", (int)maskBlendSrcValue, blendSourceNames); if (perChannelMask) { // Following condition force users to always have at least one attribute enabled m_MaterialEditor.ShaderProperty(maskmapMetal, "Affect Metal"); if ((maskmapMetal.floatValue == 0.0f) && (maskmapAO.floatValue == 0.0f) && (maskmapSmoothness.floatValue == 0.0f)) { maskmapMetal.floatValue = 1.0f; } m_MaterialEditor.ShaderProperty(maskmapAO, "Affect AO"); if ((maskmapMetal.floatValue == 0.0f) && (maskmapAO.floatValue == 0.0f) && (maskmapSmoothness.floatValue == 0.0f)) { maskmapAO.floatValue = 1.0f; } m_MaterialEditor.ShaderProperty(maskmapSmoothness, "Affect Smoothness"); if ((maskmapMetal.floatValue == 0.0f) && (maskmapAO.floatValue == 0.0f) && (maskmapSmoothness.floatValue == 0.0f)) { maskmapSmoothness.floatValue = 1.0f; } maskBlendFlags = 0; // Re-init the mask if (maskmapMetal.floatValue == 1.0f) { maskBlendFlags |= Decal.MaskBlendFlags.Metal; } if (maskmapAO.floatValue == 1.0f) { maskBlendFlags |= Decal.MaskBlendFlags.AO; } if (maskmapSmoothness.floatValue == 1.0f) { maskBlendFlags |= Decal.MaskBlendFlags.Smoothness; } } else // if perChannelMask is not enabled, force to have smoothness { maskBlendFlags = Decal.MaskBlendFlags.Smoothness; } EditorGUI.indentLevel--; } m_MaterialEditor.ShaderProperty(drawOrder, Styles.DrawOrderText); m_MaterialEditor.ShaderProperty(decalMeshDepthBias, Styles.MeshDecalDepthBiasText); m_MaterialEditor.ShaderProperty(decalBlend, Styles.decalBlendText); EditorGUI.indentLevel--; EditorGUILayout.HelpBox( "Control of AO and Metal is based on option 'Enable Metal and AO properties' in HDRP Asset.\nThere is a performance cost of enabling this option.", MessageType.Info); } if (EditorGUI.EndChangeCheck()) { normalBlendSrc.floatValue = normalBlendSrcValue; maskBlendSrc.floatValue = maskBlendSrcValue; maskBlendMode.floatValue = (float)maskBlendFlags; foreach (var obj in m_MaterialEditor.targets) { SetupMaterialKeywordsAndPassInternal((Material)obj); } } } } }
public void ShaderPropertiesGUI(Material material) { // Use default labelWidth EditorGUIUtility.labelWidth = 0f; float normalBlendSrcValue = normalBlendSrc.floatValue; float maskBlendSrcValue = maskBlendSrc.floatValue; float smoothnessRemapMinValue = smoothnessRemapMin.floatValue; float smoothnessRemapMaxValue = smoothnessRemapMax.floatValue; float AORemapMinValue = AORemapMin.floatValue; float AORemapMaxValue = AORemapMax.floatValue; Decal.MaskBlendFlags maskBlendFlags = (Decal.MaskBlendFlags)maskBlendMode.floatValue; HDRenderPipelineAsset hdrp = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset; bool perChannelMask = hdrp.currentPlatformRenderPipelineSettings.decalSettings.perChannelMask; using (var header = new HeaderScope(Styles.InputsText, (uint)Expandable.Input, this)) { if (header.expanded) { // Detect any changes to the material EditorGUI.BeginChangeCheck(); { m_MaterialEditor.TexturePropertySingleLine((material.GetFloat(kAlbedoMode) == 1.0f) ? Styles.baseColorText : Styles.baseColorText2, baseColorMap, baseColor); // Currently always display Albedo contribution as we have an albedo tint that apply EditorGUI.indentLevel++; m_MaterialEditor.ShaderProperty(albedoMode, Styles.albedoModeText); EditorGUI.indentLevel--; m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap); if (material.GetTexture(kNormalMap)) { EditorGUI.indentLevel++; normalBlendSrcValue = EditorGUILayout.Popup("Normal Opacity channel", (int)normalBlendSrcValue, blendSourceNames); EditorGUI.indentLevel--; } m_MaterialEditor.TexturePropertySingleLine(Styles.maskMapText[(int)maskBlendFlags], maskMap); if (material.GetTexture(kMaskMap)) { EditorGUI.indentLevel++; EditorGUILayout.MinMaxSlider(Styles.smoothnessRemappingText, ref smoothnessRemapMinValue, ref smoothnessRemapMaxValue, 0.0f, 1.0f); if (perChannelMask) { m_MaterialEditor.ShaderProperty(metallicScale, Styles.metallicText); EditorGUILayout.MinMaxSlider(Styles.aoRemappingText, ref AORemapMinValue, ref AORemapMaxValue, 0.0f, 1.0f); } maskBlendSrcValue = EditorGUILayout.Popup("Mask Opacity channel", (int)maskBlendSrcValue, blendSourceNames); if (perChannelMask) { bool mustDisableScope = false; if (maskmapMetal.floatValue + maskmapAO.floatValue + maskmapSmoothness.floatValue == 1.0f) { mustDisableScope = true; } using (new EditorGUI.DisabledScope(mustDisableScope && maskmapMetal.floatValue == 1.0f)) { m_MaterialEditor.ShaderProperty(maskmapMetal, "Affect Metal"); } using (new EditorGUI.DisabledScope(mustDisableScope && maskmapAO.floatValue == 1.0f)) { m_MaterialEditor.ShaderProperty(maskmapAO, "Affect AO"); } using (new EditorGUI.DisabledScope(mustDisableScope && maskmapSmoothness.floatValue == 1.0f)) { m_MaterialEditor.ShaderProperty(maskmapSmoothness, "Affect Smoothness"); } // Sanity condition in case for whatever reasons all value are 0.0 but it should never happen if ((maskmapMetal.floatValue == 0.0f) && (maskmapAO.floatValue == 0.0f) && (maskmapSmoothness.floatValue == 0.0f)) { maskmapSmoothness.floatValue = 1.0f; } maskBlendFlags = 0; // Re-init the mask if (maskmapMetal.floatValue == 1.0f) { maskBlendFlags |= Decal.MaskBlendFlags.Metal; } if (maskmapAO.floatValue == 1.0f) { maskBlendFlags |= Decal.MaskBlendFlags.AO; } if (maskmapSmoothness.floatValue == 1.0f) { maskBlendFlags |= Decal.MaskBlendFlags.Smoothness; } } else // if perChannelMask is not enabled, force to have smoothness { maskBlendFlags = Decal.MaskBlendFlags.Smoothness; } EditorGUI.indentLevel--; } m_MaterialEditor.ShaderProperty(maskMapBlueScale, Styles.maskMapBlueScaleText); m_MaterialEditor.ShaderProperty(decalBlend, Styles.decalBlendText); m_MaterialEditor.ShaderProperty(emissive, "Emissive"); if (emissive.floatValue == 1.0f) { m_MaterialEditor.ShaderProperty(useEmissiveIntensity, "Use Emission Intensity"); if (useEmissiveIntensity.floatValue == 1.0f) { m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColorLDR); using (new EditorGUILayout.HorizontalScope()) { EmissiveIntensityUnit unit = (EmissiveIntensityUnit)emissiveIntensityUnit.floatValue; if (unit == EmissiveIntensityUnit.Luminance) { m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText); } else { float evValue = LightUtils.ConvertLuminanceToEv(emissiveIntensity.floatValue); evValue = EditorGUILayout.FloatField(Styles.emissiveIntensityText, evValue); emissiveIntensity.floatValue = LightUtils.ConvertEvToLuminance(evValue); } emissiveIntensityUnit.floatValue = (float)(EmissiveIntensityUnit)EditorGUILayout.EnumPopup(unit); } } else { m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColorHDR); } } EditorGUI.indentLevel--; EditorGUILayout.HelpBox( "Control of AO and Metal is based on option 'Enable Metal and AO properties' in HDRP Asset.\nThere is a performance cost of enabling this option.", MessageType.Info); } if (EditorGUI.EndChangeCheck()) { normalBlendSrc.floatValue = normalBlendSrcValue; maskBlendSrc.floatValue = maskBlendSrcValue; maskBlendMode.floatValue = (float)maskBlendFlags; smoothnessRemapMin.floatValue = smoothnessRemapMinValue; smoothnessRemapMax.floatValue = smoothnessRemapMaxValue; AORemapMin.floatValue = AORemapMinValue; AORemapMax.floatValue = AORemapMaxValue; if (useEmissiveIntensity.floatValue == 1.0f) { emissiveColor.colorValue = emissiveColorLDR.colorValue * emissiveIntensity.floatValue; } else { emissiveColor.colorValue = emissiveColorHDR.colorValue; } foreach (var obj in m_MaterialEditor.targets) { SetupMaterialKeywordsAndPassInternal((Material)obj); } } } } EditorGUI.indentLevel++; using (var header = new HeaderScope(Styles.SortingText, (uint)Expandable.Sorting, this)) { if (header.expanded) { m_MaterialEditor.ShaderProperty(drawOrder, Styles.drawOrderText); m_MaterialEditor.ShaderProperty(decalMeshDepthBias, Styles.meshDecalDepthBiasText); } } EditorGUI.indentLevel--; }