动态改变StandardShader的RenderingMode让模型透明

最新推荐文章于 2025-05-29 16:50:25 发布
转载 最新推荐文章于 2025-05-29 16:50:25 发布 · 7k 阅读 · 14

如何用脚本动态的改变Unity5中标准材质的渲染模式，让模型透明？

先上代码：

SetMaterialRenderingMode.cs

using UnityEngine;
using System.Collections;

//设置材质的渲染模式
public class SetMaterialRenderingMode : MonoBehaviour {

    public Material mat;

	void Start () {
        setMaterialRenderingMode(mat, RenderingMode.Fade);
	}

    public enum RenderingMode{
        Opaque,
        Cutout,
        Fade,
        Transparent
    }

    //设置材质的渲染模式
    private void setMaterialRenderingMode(Material material, RenderingMode renderingMode){
        switch (renderingMode){
            case RenderingMode.Opaque:
                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
                material.SetInt("_ZWrite", 1);
                material.DisableKeyword("_ALPHATEST_ON");
                material.DisableKeyword("_ALPHABLEND_ON");
                material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
                material.renderQueue = -1;
                break;
            case RenderingMode.Cutout:
                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
                material.SetInt("_ZWrite", 1);
                material.EnableKeyword("_ALPHATEST_ON");
                material.DisableKeyword("_ALPHABLEND_ON");
                material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
                material.renderQueue = 2450;
                break;
            case RenderingMode.Fade:
                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                material.SetInt("_ZWrite", 0);
                material.DisableKeyword("_ALPHATEST_ON");
                material.EnableKeyword("_ALPHABLEND_ON");
                material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
                material.renderQueue = 3000;
                break;
            case RenderingMode.Transparent:
                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                material.SetInt("_ZWrite", 0);
                material.DisableKeyword("_ALPHATEST_ON");
                material.DisableKeyword("_ALPHABLEND_ON");
                material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
                material.renderQueue = 3000;
                break;
        }
    }
	
}

最近在做项目的时候遇到了一个需要动态切换模型透明、不透明效果的功能。unity4.x的时候是切换材质的shader，但是现在unity5的标准材质已经可以切换渲染模式了，那么肯定有方法在不更换shader的前提下直接切换材质的透明、不透明效果。自己花了不少时间，尝试设置Material和Shader的属性，发现都没有实现效果，很是挠头啊，肯定是有哪些地方没有弄明白导致失败，因为在编辑模式下，Inspector面板中标准材质已经提供了一个切换渲染模式的功能按钮，Rendering Mode，可以实现透明和不透明之间的切换，而且有4种模式。那么答案肯定就在这个UI的源代码里。在网上查了不少资料，发现标准材质的UI脚本叫做StandardShaderGUI.cs，又经过一番搜索终于在一个外国论坛帖子的回复中找到了外国同行分享的标准材质GUI的源代码，这个源代码已经被外国友人改过了，所以有些地方可能和官方源代码有些出入，不过大部分应该相同，先上代码：

CustomStandardShaderGUI.cs

using System;
using UnityEngine;
 
namespace UnityEditor
{
    internal class CustomStandardShaderGUI : ShaderGUI
{
    private enum WorkflowMode
    {
        Specular,
        Metallic,
        Dielectric
    }
 
    public enum BlendMode
    {
        Opaque,
        Cutout,
        Fade,        // Old school alpha-blending mode, fresnel does not affect amount of transparency
        Transparent // Physically plausible transparency mode, implemented as alpha pre-multiply
    }
 
    private static class Styles
    {
        public static GUIStyle optionsButton = "PaneOptions";
        public static GUIContent uvSetLabel = new GUIContent("UV Set");
        public static GUIContent[] uvSetOptions = new GUIContent[] { new GUIContent("UV channel 0"), new GUIContent("UV channel 1") };
 
        public static string emptyTootip = "";
        public static GUIContent albedoText = new GUIContent("Albedo", "Albedo (RGB) and Transparency (A)");
        public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff");
        public static GUIContent specularMapText = new GUIContent("Specular", "Specular (RGB) and Smoothness (A)");
        public static GUIContent metallicMapText = new GUIContent("Metallic", "Metallic (R) and Smoothness (A)");
        public static GUIContent smoothnessText = new GUIContent("Smoothness", "");
        public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map");
        public static GUIContent heightMapText = new GUIContent("Height Map", "Height Map (G)");
        public static GUIContent occlusionText = new GUIContent("Occlusion", "Occlusion (G)");
        public static GUIContent emissionText = new GUIContent("Emission", "Emission (RGB)");
        public static GUIContent detailMaskText = new GUIContent("Detail Mask", "Mask for Secondary Maps (A)");
        public static GUIContent detailAlbedoText = new GUIContent("Detail Albedo x2", "Albedo (RGB) multiplied by 2");
        public static GUIContent detailNormalMapText = new GUIContent("Normal Map", "Normal Map");
 
        public static string whiteSpaceString = " ";
        public static string primaryMapsText = "Main Maps";
        public static string secondaryMapsText = "Secondary Maps";
        public static string renderingMode = "Rendering Mode";
        public static GUIContent emissiveWarning = new GUIContent ("Emissive value is animated but the material has not been configured to support emissive. Please make sure the material itself has some amount of emissive.");
        public static GUIContent emissiveColorWarning = new GUIContent ("Ensure emissive color is non-black for emission to have effect.");
        public static readonly string[] blendNames = Enum.GetNames (typeof (BlendMode));
    }
 
    MaterialProperty blendMode = null;
    MaterialProperty albedoMap = null;
    MaterialProperty albedoColor = null;
    MaterialProperty alphaCutoff = null;
    MaterialProperty specularMap = null;
    MaterialProperty specularColor = null;
    MaterialProperty metallicMap = null;
    MaterialProperty metallic = null;
    MaterialProperty smoothness = null;
    MaterialProperty bumpScale = null;
    MaterialProperty bumpMap = null;
    MaterialProperty occlusionStrength = null;
    MaterialProperty occlusionMap = null;
    MaterialProperty heigtMapScale = null;
    MaterialProperty heightMap = null;
    MaterialProperty emissionScaleUI = null;
    MaterialProperty emissionColorUI = null;
    MaterialProperty emissionColorForRendering = null;
    MaterialProperty emissionMap = null;
    MaterialProperty detailMask = null;
    MaterialProperty detailAlbedoMap = null;
    MaterialProperty detailNormalMapScale = null;
    MaterialProperty detailNormalMap = null;
    MaterialProperty uvSetSecondary = null;
 
    MaterialEditor m_MaterialEditor;
    WorkflowMode m_WorkflowMode = WorkflowMode.Specular;
 
    bool m_FirstTimeApply = true;
 
    public void FindProperties (MaterialProperty[] props)
    {
        blendMode = FindProperty ("_Mode", props);
        albedoMap = FindProperty ("_MainTex", props);
        albedoColor = FindProperty ("_Color", props);
        alphaCutoff = FindProperty ("_Cutoff", props);
        specularMap = FindProperty ("_SpecGlossMap", props, false);
        specularColor = FindProperty ("_SpecColor", props, false);
        metallicMap = FindProperty ("_MetallicGlossMap", props, false);
        metallic = FindProperty ("_Metallic", props, false);
        if (specularMap != null && specularColor != null)
            m_WorkflowMode = WorkflowMode.Specular;
        else if (metallicMap != null && metallic != null)
            m_WorkflowMode = WorkflowMode.Metallic;
        else
            m_WorkflowMode = WorkflowMode.Dielectric;
        smoothness = FindProperty ("_Glossiness", props);
        bumpScale = FindProperty ("_BumpScale", props);
        bumpMap = FindProperty ("_BumpMap", props);
        heigtMapScale = FindProperty ("_Parallax", props);
        heightMap = FindProperty("_ParallaxMap", props);
        occlusionStrength = FindProperty ("_OcclusionStrength", props);
        occlusionMap = FindProperty ("_OcclusionMap", props);
        emissionScaleUI = FindProperty ("_EmissionScaleUI", props);
        emissionColorUI = FindProperty ("_EmissionColorUI", props);
        emissionColorForRendering = FindProperty ("_EmissionColor", props);
        emissionMap = FindProperty ("_EmissionMap", props);
        detailMask = FindProperty ("_DetailMask", props);
        detailAlbedoMap = FindProperty ("_DetailAlbedoMap", props);
        detailNormalMapScale = FindProperty ("_DetailNormalMapScale", props);
        detailNormalMap = FindProperty ("_DetailNormalMap", props);
        uvSetSecondary = FindProperty ("_UVSec", props);
    }
 
    public override void OnGUI (MaterialEditor materialEditor, MaterialProperty[] props)
    {
        FindProperties (props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
        m_MaterialEditor = materialEditor;
        Material material = materialEditor.target as Material;
 
        ShaderPropertiesGUI (material);
 
        // Make sure that needed keywords are set up if we're switching some existing
        // material to a standard shader.
        if (m_FirstTimeApply)
        {
            SetMaterialKeywords (material, m_WorkflowMode);
            m_FirstTimeApply = false;
        }
    }
 
    public void ShaderPropertiesGUI (Material material)
    {
        // Use default labelWidth
        EditorGUIUtility.labelWidth = 0f;
 
        // Detect any changes to the material
        EditorGUI.BeginChangeCheck();
        {
            BlendModePopup();
 
            // Primary properties
            GUILayout.Label (Styles.primaryMapsText, EditorStyles.boldLabel);
            DoAlbedoArea(material);
            DoSpecularMetallicArea();
            m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, bumpMap, bumpMap.textureValue != null ? bumpScale : null);
            m_MaterialEditor.TexturePropertySingleLine(Styles.heightMapText, heightMap, heightMap.textureValue != null ? heigtMapScale : null);
            m_MaterialEditor.TexturePropertySingleLine(Styles.occlusionText, occlusionMap, occlusionMap.textureValue != null ? occlusionStrength : null);
            DoEmissionArea(material);
            m_MaterialEditor.TexturePropertySingleLine(Styles.detailMaskText, detailMask);
            EditorGUI.BeginChangeCheck();
            m_MaterialEditor.TextureScaleOffsetProperty(albedoMap);
            if (EditorGUI.EndChangeCheck())
                emissionMap.textureScaleAndOffset = albedoMap.textureScaleAndOffset; // Apply the main texture scale and offset to the emission texture as well, for Enlighten's sake
 
            EditorGUILayout.Space();
 
            // Secondary properties
            GUILayout.Label(Styles.secondaryMapsText, EditorStyles.boldLabel);
            m_MaterialEditor.TexturePropertySingleLine(Styles.detailAlbedoText, detailAlbedoMap);
            m_MaterialEditor.TexturePropertySingleLine(Styles.detailNormalMapText, detailNormalMap, detailNormalMapScale);
            m_MaterialEditor.TextureScaleOffsetProperty(detailAlbedoMap);
            m_MaterialEditor.ShaderProperty(uvSetSecondary, Styles.uvSetLabel.text);
 
            EditorGUILayout.Space();
 
        }
        if (EditorGUI.EndChangeCheck())
        {
            foreach (var obj in blendMode.targets)
                MaterialChanged((Material)obj, m_WorkflowMode);
        }
    }
 
    internal void DetermineWorkflow(MaterialProperty[] props)
    {
        if (FindProperty("_SpecGlossMap", props, false) != null && FindProperty("_SpecColor", props, false) != null)
            m_WorkflowMode = WorkflowMode.Specular;
        else if (FindProperty("_MetallicGlossMap", props, false) != null && FindProperty("_Metallic", props, false) != null)
            m_WorkflowMode = WorkflowMode.Metallic;
        else
            m_WorkflowMode = WorkflowMode.Dielectric;
    }
 
    public override void AssignNewShaderToMaterial (Material material, Shader oldShader, Shader newShader)
    {
        base.AssignNewShaderToMaterial(material, oldShader, newShader);
 
        if (oldShader == null || !oldShader.name.Contains("Legacy Shaders/"))
            return;
 
        BlendMode blendMode = BlendMode.Opaque;
        if (oldShader.name.Contains("/Transparent/Cutout/"))
        {
            blendMode = BlendMode.Cutout;
        }
        else if (oldShader.name.Contains("/Transparent/"))
        {
            // NOTE: legacy shaders did not provide physically based transparency
            // therefore Fade mode
            blendMode = BlendMode.Fade;
        }
        material.SetFloat("_Mode", (float)blendMode);
 
        //DetermineWorkflow( ShaderUtil.GetMaterialProperties(new Material[] { material }) );
        MaterialChanged(material, m_WorkflowMode);
    }
 
    void BlendModePopup()
    {
        EditorGUI.showMixedValue = http://blog.youkuaiyun.com/zhangyukof/article/details/blendMode.hasMixedValue;
        var mode = (BlendMode)blendMode.floatValue;
        EditorGUI.BeginChangeCheck();
        mode = (BlendMode)EditorGUILayout.Popup(Styles.renderingMode, (int)mode, Styles.blendNames);
        if (EditorGUI.EndChangeCheck())
        {
            m_MaterialEditor.RegisterPropertyChangeUndo("Rendering Mode");
            blendMode.floatValue = http://blog.youkuaiyun.com/zhangyukof/article/details/(float)mode;
        }
 
        EditorGUI.showMixedValue = false;
    }
 
    void DoAlbedoArea(Material material)
    {
        m_MaterialEditor.TexturePropertySingleLine(Styles.albedoText, albedoMap, albedoColor);
        if (((BlendMode)material.GetFloat("_Mode") == BlendMode.Cutout))
        {
            m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text, MaterialEditor.kMiniTextureFieldLabelIndentLevel+1);
        }
    }
 
    void DoEmissionArea(Material material)
    {
        bool showEmissionColorAndGIControls = emissionScaleUI.floatValue > 0f;
        bool hadEmissionTexture = emissionMap.textureValue != null;
 
        // Do controls
        m_MaterialEditor.TexturePropertySingleLine(Styles.emissionText, emissionMap, showEmissionColorAndGIControls ? emissionColorUI : null, emissionScaleUI);
 
        // Set default emissionScaleUI if texture was assigned
        if (emissionMap.textureValue != null && !hadEmissionTexture && emissionScaleUI.floatValue <= 0f)
            emissionScaleUI.floatValue = http://blog.youkuaiyun.com/zhangyukof/article/details/1.0f;
 
        // Dynamic Lightmapping mode
        if (showEmissionColorAndGIControls)
        {
            bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled(EvalFinalEmissionColor(material));
            EditorGUI.BeginDisabledGroup(!shouldEmissionBeEnabled);
 
            m_MaterialEditor.LightmapEmissionProperty (MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
 
            EditorGUI.EndDisabledGroup();
        }
 
        if (!HasValidEmissiveKeyword(material))
        {
            EditorGUILayout.HelpBox(Styles.emissiveWarning.text, MessageType.Warning);
        }
 
    }
 
    void DoSpecularMetallicArea()
    {
        if (m_WorkflowMode == WorkflowMode.Specular)
        {
            if (specularMap.textureValue == null)
                m_MaterialEditor.TexturePropertyTwoLines(Styles.specularMapText, specularMap, specularColor, Styles.smoothnessText, smoothness);
            else
                m_MaterialEditor.TexturePropertySingleLine(Styles.specularMapText, specularMap);
 
        }
        else if (m_WorkflowMode == WorkflowMode.Metallic)
        {
            if (metallicMap.textureValue == null)
                m_MaterialEditor.TexturePropertyTwoLines(Styles.metallicMapText, metallicMap, metallic, Styles.smoothnessText, smoothness);
            else
                m_MaterialEditor.TexturePropertySingleLine(Styles.metallicMapText, metallicMap);
        }
    }
 
    public static void SetupMaterialWithBlendMode(Material material, BlendMode blendMode)
    {
        switch (blendMode)
        {
            case BlendMode.Opaque:
                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
                material.SetInt("_ZWrite", 1);
                material.DisableKeyword("_ALPHATEST_ON");
                material.DisableKeyword("_ALPHABLEND_ON");
                material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
                material.renderQueue = -1;
                break;
            case BlendMode.Cutout:
                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
                material.SetInt("_ZWrite", 1);
                material.EnableKeyword("_ALPHATEST_ON");
                material.DisableKeyword("_ALPHABLEND_ON");
                material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
                material.renderQueue = 2450;
                break;
            case BlendMode.Fade:
                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                material.SetInt("_ZWrite", 0);
                material.DisableKeyword("_ALPHATEST_ON");
                material.EnableKeyword("_ALPHABLEND_ON");
                material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
                material.renderQueue = 3000;
                break;
            case BlendMode.Transparent:
                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                material.SetInt("_ZWrite", 0);
                material.DisableKeyword("_ALPHATEST_ON");
                material.DisableKeyword("_ALPHABLEND_ON");
                material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
                material.renderQueue = 3000;
                break;
        }
    }
 
    // Calculate final HDR _EmissionColor (gamma space) from _EmissionColorUI (LDR, gamma) & _EmissionScaleUI (gamma)
    static Color EvalFinalEmissionColor(Material material)
    {
        return material.GetColor("_EmissionColorUI") * material.GetFloat("_EmissionScaleUI");
    }
 
    static bool ShouldEmissionBeEnabled (Color color)
    {
        return color.grayscale > (0.1f / 255.0f);
    }
 
    static void SetMaterialKeywords(Material material, WorkflowMode workflowMode)
    {
        // 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"));
        if (workflowMode == WorkflowMode.Specular)
            SetKeyword (material, "_SPECGLOSSMAP", material.GetTexture ("_SpecGlossMap"));
        else if (workflowMode == WorkflowMode.Metallic)
            SetKeyword (material, "_METALLICGLOSSMAP", material.GetTexture ("_MetallicGlossMap"));
        SetKeyword (material, "_PARALLAXMAP", material.GetTexture ("_ParallaxMap"));
        SetKeyword (material, "_DETAIL_MULX2", material.GetTexture ("_DetailAlbedoMap") || material.GetTexture ("_DetailNormalMap"));
 
        bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled (material.GetColor("_EmissionColor"));
        SetKeyword (material, "_EMISSION", shouldEmissionBeEnabled);
 
        // 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;
        }
    }
 
    bool HasValidEmissiveKeyword (Material material)
    {
        // Material animation might be out of sync with the material keyword.
        // So if the emission support is disabled on the material, but the property blocks have a value that requires it, then we need to show a warning.
        // (note: (Renderer MaterialPropertyBlock applies its values to emissionColorForRendering))
        bool hasEmissionKeyword = material.IsKeywordEnabled ("_EMISSION");
        if (!hasEmissionKeyword && ShouldEmissionBeEnabled (emissionColorForRendering.colorValue))
            return false;
        else
            return true;
    }
 
    static void MaterialChanged(Material material, WorkflowMode workflowMode)
    {
        // Clamp EmissionScale to always positive
        if (material.GetFloat("_EmissionScaleUI") < 0.0f)
            material.SetFloat("_EmissionScaleUI", 0.0f);
 
        // Apply combined emission value
        Color emissionColorOut = EvalFinalEmissionColor (material);
        material.SetColor("_EmissionColor", emissionColorOut);
 
        // Handle Blending modes
        SetupMaterialWithBlendMode(material, (BlendMode)material.GetFloat("_Mode"));
 
        SetMaterialKeywords(material, workflowMode);
    }
 
    static void SetKeyword(Material m, string keyword, bool state)
    {
        if (state)
            m.EnableKeyword (keyword);
        else
            m.DisableKeyword (keyword);
    }
}
 
} // namespace UnityEditor

搜索了一下RenderingMode的相关能容，在代码的283行找到了SetupMaterialWithBlendMode方法，这个方法中的内容就是我们切换渲染模式用到的代码了，整理后代码就是文章最上方的setMaterialRenderingMode方法了，有两个参数，第一个是材质，二个是渲染模式。

OK，问题解决。

FoxGameY
关注
Rendering Mode 渲染模式 Standard Shader系列5
cangod的博客
01-06 2095
Rendering Mode 渲染模式 本文档主要是对Unity官方手册的个人理解与总结（其实以翻译记录为主：&amp;gt;） 仅作为个人学习使用，不得作为商业用途，欢迎转载，并请注明出处。 文章中涉及到的操作都是基于Unity2018.1版本 参考链接：https://docs.unity3d.com/Manual/StandardShaderMaterialParameterRenderingMod...
Unity通过代码修改Standard shader的rendering mode属性
天富儿的博客
03-23 2666
Unity通过代码修改Standard shader的rendering mode参考原文自己的测试参考文链接 参考原文 材质编辑器上只有一个选项： 通过代码修改的话，需要知道那几个选项对应的渲染参数。unity的着色器扩展资源里是有Standard着色器的材质球GUI代码的，可以直接参考这里： 动态改变StandardShader的RenderingMode让模型透明 知道这些了就很好办了，注...
设置 Material 的 RenderMode 设置材质球的渲染模式
ysong0913的博客
11-27 1086
public enum RenderingMode { Opaque, Cutout, Fade, Transparent, } public static void SetMaterialRenderingMode(Material material, RenderingMode renderingMod...
Unity如何改变材质的Rendering Mode
ultramansail的博客
08-13 2555
我们在使用Unity开发的过程中，时常要使得材质有时候变透明，有时候不透明，在属性面板中直接把材质设置成Cutout或Transparent模式又时常能看到物体的背面，效果很不理想，但是通过以下脚本可以动态改变材质的Rendering Mode。 using System.Collections; using System.Collections.Generic; using UnityEng...
Unity 3D动态修改Shader状态，使物体透明等等
weixin_34390996的博客
04-29 538
Unity动态改Shader状态透明 本文提供全流程，中文翻译。 Chinar 坚持将简单的生活方式，带给世人！（拥有更好的阅读体验 —— 高分辨率用户请根据需求调整网页缩放比例） Chinar —— 心分享、心创新！助力快速完成 Shader 的动态修改为新手节省宝贵的时间，避免采坑！ Chinar 教程效果： ...
Standard Shader 的渲染模式详解
分享知识，拥抱变化
05-29 920
Unity的StandardShader提供四种渲染模式：Opaque（不透明）适合实心物体；Cutout（裁剪透明）适用于边缘清晰的透明物体；Transparent（透明）支持半透明效果；Fade（淡入淡出）用于整体透明度变化。每种模式有不同的特性和性能影响，开发者应根据场景需求（如视觉效果、渲染顺序、性能要求）合理选择，并通过代码调整材质参数实现动态切换。注意透明物体的渲染顺序和纹理要求，以优化视觉效果和性能。
Standard Shader 材质参数详解
分享知识，拥抱变化
05-29 783
Unity的StandardShader参数详解 摘要：Unity的StandardShader提供了一套完整的PBR材质参数，支持金属和高光两种工作流。关键参数包括：渲染模式（Opaque/Cutout/Fade/Transparent）、反照率颜色、金属度/高光滑度、平滑度、法线贴图、高度贴图、环境光遮挡等。这些参数协同工作可模拟各类真实材质，如金属、玻璃、布料等。金属工作流更适合物理准确表现，而高光工作流允许更多艺术控制。优化建议包括使用纹理图集、烘焙法线图以及谨慎使用自发光等。通过合理组合这些参数，
unity中模型可以通过修改Fade使其透明，但是打包成pc包后无法透明
IT_choshim的博客
11-30 5044
项目中一些需要做透明的物体Rendering Mode为Opaque，这是没办法做透明的，必须修改为Fade。 如下： 在要透明之前先将材质Rendering Mode修改为Fade，然后修改color.a 在unity可以正常透明，但是达成pc包或者webgl包是无法隐藏的 原因是因为打包时没将Stanard shader打包进去，刚开始强加入的shader 如图： 但是这样强加入会造成变体过多影响打包速度以及包体大小，所以这种方法否决 Standard ..
[Unity常见小问题]打包ios后无法修改模型透明度
qq_35064654的博客
05-06 490
在Editor下可以使用如下代码去修改模型的材质的透明度，但是打包ios后无法对透明度进行修改且没有任何warning和error。
U3D render type runtime Unity5.5内置着色器StandardShaderGUI
yaoyutian的博客
09-05 780
public static void SetupMaterialWithBlendMode(Material material, BlendMode blendMode) { switch (blendMode) { case BlendMode.Opaque: ...
代码动态修改Shader的_MainTex后，Image不变
weixin_44124970的博客
08-15 423
如题在网上找了很多修改Shader的_MainTex的代码，但是没见过这问题。
Unity通过代码修改Standard shader的rendering mode
qiminixi的专栏
10-31 6661
材质编辑器上只有一个选项： 通过代码修改的话，需要知道那几个选项对应的渲染参数。unity的着色器扩展资源里是有Standard着色器的材质球GUI代码的，可以直接参考这里： 动态改变StandardShader的RenderingMode让模型透明 知道这些了就很好办了，注意除了switch-case里的代码外，还要设置_Modle参数。例如改为半透明模式的代码如下，基本上直接拷过
Unity中使用代码动态修改URP管线下的标准材质是否透明
weixin_39562801的博客
03-06 979
/修改为透明//修改为不透明。
Unity Standard-SurfaceShader透明测试与透明混合
weixin_42565127的博客
12-19 494
Unity SurfaceShader 透明测试与透明混合
Unity在运行时（代码中）设置材质的渲染模式（RenderingMode）
05-18 1073
在Unity中，有些少数情况下我们需要用代码来创建材质。比如说在材质非常多，而仅仅是纹理不一样的时候。 而用代码创建的材质是没有对应的资源文件的，我们也就无法使用Inspector来设置它的Rendering Mode。 关于Rendering Mode，许我稍作介绍： 材质(Material)的属性检视面板(Inspector)里的第一项为渲染模式(RenderingMod...
LayaAir 2.0.2, 2.1.0自定义shader使用动态批处理
m0_37951757的博客
06-13 2973
许多3D引擎都对动态批处理进行了较好的支持，使得使用相同材质的多个模型可以合并为同一个批次提交到 渲染，从而降低drawcall，充分利用GPU流水线，提升渲染效率。 垃圾box在2.0.0开始也尝试对此进行了支持，最开始的版本限制10顶点以内，2.0.2开始则移除了此限制，但不愧是垃圾box，2.0.2版本的动态合批与粒子系统产生了冲突，导致打包到微信的粒子位置修改无效，因此他们在2.1.0做...
Unity Shader Rendering Mode
jk823394954的专栏
11-08 4285
这一节我们来看一下Unity Shader的渲染模式 我们首先创建一个Plane,然后给这个平面附上一张纹理贴图如下图 如果我们是直接把纹理图片拖到Plane上的，那么Unity回味我们生成一个和纹理图片相同名字的材质，我们选中面板Plane,然后我们看一下Inspector窗口 我们看到Rendering Mode这个参数，它就是控制渲染模式的。我们点击渲染
怎么让模型在特效例子上层
最新发布
10-30
- **注意**：需使用支持透明队列的Shader（如Standard的`Rendering Mode = Transparent`） #### 3. **Sorting Layer分层控制（适用UI系统）** [^2] ```csharp // UGUI Canvas设置 canvas.sortingLayerName = ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值