Exemplo n.º 1
0
        static void RemapTransparencyCurves(MaterialDescription description, AnimationClip[] clips)
        {
            // For some reason, Opacity is never animated, we have to use TransparencyFactor and TransparentColor
            for (int i = 0; i < clips.Length; i++)
            {
                bool           foundTransparencyCurve = false;
                AnimationCurve curve;
                if (description.TryGetAnimationCurve(clips[i].name, "TransparencyFactor", out curve))
                {
                    ConvertKeys(curve, ConvertFloatOneMinus);
                    clips[i].SetCurve("", typeof(Material), "_BaseColor.a", curve);
                    foundTransparencyCurve = true;
                }
                else if (description.TryGetAnimationCurve(clips[i].name, "TransparentColor.x", out curve))
                {
                    ConvertKeys(curve, ConvertFloatOneMinus);
                    clips[i].SetCurve("", typeof(Material), "_BaseColor.a", curve);
                    foundTransparencyCurve = true;
                }

                if (foundTransparencyCurve && !description.HasAnimationCurveInClip(clips[i].name, "DiffuseColor"))
                {
                    Vector4 diffuseColor;
                    description.TryGetProperty("DiffuseColor", out diffuseColor);
                    clips[i].SetCurve("", typeof(Material), "_BaseColor.r", AnimationCurve.Constant(0.0f, 1.0f, diffuseColor.x));
                    clips[i].SetCurve("", typeof(Material), "_BaseColor.g", AnimationCurve.Constant(0.0f, 1.0f, diffuseColor.y));
                    clips[i].SetCurve("", typeof(Material), "_BaseColor.b", AnimationCurve.Constant(0.0f, 1.0f, diffuseColor.z));
                }
            }
        }
        public void OnPreprocessMaterialDescription(MaterialDescription description, Material material, AnimationClip[] clips)
        {
            var pipelineAsset = GraphicsSettings.currentRenderPipeline;

            if (!pipelineAsset || pipelineAsset.GetType() != typeof(HDRenderPipelineAsset))
            {
                return;
            }

            if (IsAutodeskInteractiveMaterial(description))
            {
                float   floatProperty;
                Vector4 vectorProperty;
                TexturePropertyDescription textureProperty;

                bool isMasked      = description.TryGetProperty("mask_threshold", out floatProperty);
                bool isTransparent = description.TryGetProperty("opacity", out floatProperty);

                Shader shader;
                if (isMasked)
                {
                    shader = GraphicsSettings.currentRenderPipeline.autodeskInteractiveMaskedShader;
                }
                else if (isTransparent)
                {
                    shader = GraphicsSettings.currentRenderPipeline.autodeskInteractiveTransparentShader;
                }
                else
                {
                    shader = GraphicsSettings.currentRenderPipeline.autodeskInteractiveShader;
                }

                if (shader == null)
                {
                    return;
                }

                material.shader = shader;
                foreach (var clip in clips)
                {
                    clip.ClearCurves();
                }

                if (description.TryGetProperty("base_color", out vectorProperty))
                {
                    material.SetColor("_Color", vectorProperty);
                }
                if (description.TryGetProperty("emissive", out vectorProperty))
                {
                    material.SetColor("_EmissionColor", vectorProperty);
                }

                if (description.TryGetProperty("roughness", out floatProperty))
                {
                    material.SetFloat("_Roughness", floatProperty);
                }

                if (description.TryGetProperty("metallic", out floatProperty))
                {
                    material.SetFloat("_Metallic", floatProperty);
                }

                if (description.TryGetProperty("uvTransform", out vectorProperty))
                {
                    material.SetVector("_UvOffset", new Vector4(vectorProperty.x, vectorProperty.y, .0f, .0f));
                    material.SetVector("_UvTiling", new Vector4(vectorProperty.w, vectorProperty.z, .0f, .0f));
                }

                if (description.TryGetProperty("TEX_color_map", out textureProperty))
                {
                    material.SetTexture("_MainTex", textureProperty.texture);
                    material.SetFloat("_UseColorMap", 1.0f);
                }
                else
                {
                    material.SetFloat("_UseColorMap", 0.0f);
                }

                if (description.TryGetProperty("TEX_normal_map", out textureProperty))
                {
                    material.SetTexture("_BumpMap", textureProperty.texture);
                    material.SetFloat("_UseNormalMap", 1.0f);
                }
                else
                {
                    material.SetFloat("_UseNormalMap", 0.0f);
                }

                if (description.TryGetProperty("TEX_roughness_map", out textureProperty))
                {
                    material.SetTexture("RoughnessMap", textureProperty.texture);
                    material.SetFloat("_UseRoughnessMap", 1.0f);
                }
                else
                {
                    material.SetFloat("_UseRoughnessMap", 0.0f);
                }

                if (description.TryGetProperty("TEX_metallic_map", out textureProperty))
                {
                    material.SetTexture("_MetallicMap", textureProperty.texture);
                    material.SetFloat("_UseMetallicMap", 1.0f);
                }
                else
                {
                    material.SetFloat("_UseMetallicMap", 0.0f);
                }

                if (description.TryGetProperty("TEX_emissive_map", out textureProperty))
                {
                    material.SetTexture("_EmissionMap", textureProperty.texture);
                    material.SetFloat("_UseEmissiveMap", 1.0f);
                }
                else
                {
                    material.SetFloat("_UseEmissiveMap", 0.0f);
                }

                if (description.TryGetProperty("hasTransparencyTexture", out floatProperty))
                {
                    material.SetFloat("_UseOpacityMap", floatProperty);
                }

                if (description.TryGetProperty("transparencyMaskThreshold", out floatProperty))
                {
                    material.SetFloat("_OpacityThreshold", floatProperty);
                }

                if (description.TryGetProperty("TEX_ao_map", out textureProperty))
                {
                    var tex = AssetDatabase.LoadAssetAtPath <Texture>(textureProperty.relativePath);
                    material.SetTexture("AoMap", tex);
                    material.SetFloat("UseAoMap", 1.0f);
                }
                else
                {
                    material.SetFloat("UseAoMap", 0.0f);
                }

                RemapColorCurves(description, clips, "base_color", "_Color");
                RemapCurve(description, clips, "mask_threshold", "_Cutoff");
                RemapCurve(description, clips, "metallic", "_Metallic");
                RemapCurve(description, clips, "roughness", "_Glossiness");

                for (int i = 0; i < clips.Length; i++)
                {
                    if (description.HasAnimationCurveInClip(clips[i].name, "uv_scale.x") || description.HasAnimationCurveInClip(clips[i].name, "uv_scale.y"))
                    {
                        AnimationCurve curve;
                        if (description.TryGetAnimationCurve(clips[i].name, "uv_scale.x", out curve))
                        {
                            clips[i].SetCurve("", typeof(Material), "_UvTiling.x", curve);
                        }
                        else
                        {
                            clips[i].SetCurve("", typeof(Material), "_UvTiling.x", AnimationCurve.Constant(0.0f, 1.0f, 1.0f));
                        }

                        if (description.TryGetAnimationCurve(clips[i].name, "uv_scale.y", out curve))
                        {
                            clips[i].SetCurve("", typeof(Material), "_UvTiling.y", curve);
                        }
                        else
                        {
                            clips[i].SetCurve("", typeof(Material), "_UvTiling.y", AnimationCurve.Constant(0.0f, 1.0f, 1.0f));
                        }
                    }

                    if (description.HasAnimationCurveInClip(clips[i].name, "uv_offset.x") || description.HasAnimationCurveInClip(clips[i].name, "uv_offset.y"))
                    {
                        AnimationCurve curve;
                        if (description.TryGetAnimationCurve(clips[i].name, "uv_offset.x", out curve))
                        {
                            clips[i].SetCurve("", typeof(Material), "_UvOffset.x", curve);
                        }
                        else
                        {
                            clips[i].SetCurve("", typeof(Material), "_UvOffset.x", AnimationCurve.Constant(0.0f, 1.0f, 0.0f));
                        }

                        if (description.TryGetAnimationCurve(clips[i].name, "uv_offset.y", out curve))
                        {
                            ConvertKeys(curve, ConvertFloatNegate);
                            clips[i].SetCurve("", typeof(Material), "_UvOffset.y", curve);
                        }
                        else
                        {
                            clips[i].SetCurve("", typeof(Material), "_UvOffset.y", AnimationCurve.Constant(0.0f, 1.0f, 0.0f));
                        }
                    }
                }

                if (description.HasAnimationCurve("emissive_intensity"))
                {
                    Vector4 emissiveColor;
                    description.TryGetProperty("emissive", out emissiveColor);

                    for (int i = 0; i < clips.Length; i++)
                    {
                        AnimationCurve curve;
                        description.TryGetAnimationCurve(clips[i].name, "emissive_intensity", out curve);
                        // remap emissive intensity to emission color
                        clips[i].SetCurve("", typeof(Material), "_EmissionColor.r", curve);
                        clips[i].SetCurve("", typeof(Material), "_EmissionColor.g", curve);
                        clips[i].SetCurve("", typeof(Material), "_EmissionColor.b", curve);
                    }
                }
                else if (description.TryGetProperty("emissive", out vectorProperty))
                {
                    if (vectorProperty.x > 0.0f || vectorProperty.y > 0.0f || vectorProperty.z > 0.0f)
                    {
                        material.globalIlluminationFlags |= MaterialGlobalIlluminationFlags.RealtimeEmissive;
                        material.EnableKeyword("_EMISSION");
                    }

                    if (description.TryGetProperty("emissive_intensity", out floatProperty))
                    {
                        vectorProperty *= floatProperty;
                    }

                    material.SetColor("_EmissionColor", vectorProperty);


                    if (description.HasAnimationCurve("emissive.x"))
                    {
                        if (description.HasAnimationCurve("emissive_intensity"))
                        {
                            // combine color and intensity.
                            for (int i = 0; i < clips.Length; i++)
                            {
                                AnimationCurve curve;
                                AnimationCurve intensityCurve;
                                description.TryGetAnimationCurve(clips[i].name, "emissive_intensity", out intensityCurve);

                                description.TryGetAnimationCurve(clips[i].name, "emissive.x", out curve);
                                MultiplyCurves(curve, intensityCurve);
                                clips[i].SetCurve("", typeof(Material), "_EmissionColor.r", curve);

                                description.TryGetAnimationCurve(clips[i].name, "emissive.y", out curve);
                                MultiplyCurves(curve, intensityCurve);
                                clips[i].SetCurve("", typeof(Material), "_EmissionColor.g", curve);

                                description.TryGetAnimationCurve(clips[i].name, "emissive.z", out curve);
                                MultiplyCurves(curve, intensityCurve);
                                clips[i].SetCurve("", typeof(Material), "_EmissionColor.b", curve);
                            }
                        }
                        else
                        {
                            RemapColorCurves(description, clips, "emissive", "_EmissionColor");
                        }
                    }
                    else if (description.HasAnimationCurve("emissive_intensity"))
                    {
                        Vector4 emissiveColor;
                        description.TryGetProperty("emissive", out emissiveColor);

                        for (int i = 0; i < clips.Length; i++)
                        {
                            AnimationCurve curve;
                            description.TryGetAnimationCurve(clips[i].name, "emissive_intensity", out curve);
                            // remap emissive intensity to emission color
                            AnimationCurve curveR = new AnimationCurve();
                            ConvertAndCopyKeys(curveR, curve, value => ConvertFloatMultiply(emissiveColor.x, value));
                            clips[i].SetCurve("", typeof(Material), "_EmissionColor.r", curveR);

                            AnimationCurve curveG = new AnimationCurve();
                            ConvertAndCopyKeys(curveG, curve, value => ConvertFloatMultiply(emissiveColor.y, value));
                            clips[i].SetCurve("", typeof(Material), "_EmissionColor.g", curveG);

                            AnimationCurve curveB = new AnimationCurve();
                            ConvertAndCopyKeys(curveB, curve, value => ConvertFloatMultiply(emissiveColor.z, value));
                            clips[i].SetCurve("", typeof(Material), "_EmissionColor.b", curveB);
                        }
                    }
                }
            }
        }
        void CreateFromAutodeskInteractiveMaterial(MaterialDescription description, Material material, AnimationClip[] clips)
        {
            var shader = Shader.Find("Autodesk Interactive");

            if (shader == null)
            {
                context.LogImportError("FBXMaterialDescriptionPreprocessor cannot find a shader named 'Autodesk Interactive'.");
                return;
            }
            material.shader = shader;

            float   floatProperty;
            Vector4 vectorProperty;
            TexturePropertyDescription textureProperty;
            AnimationCurve             curve;

            Vector2 uvOffset = new Vector2(0.0f, 0.0f);
            Vector2 uvScale  = new Vector2(1.0f, 1.0f);

            if (description.TryGetProperty("uv_offset", out vectorProperty))
            {
                uvOffset.x = vectorProperty.x;
                uvOffset.y = -vectorProperty.y;
            }
            if (description.TryGetProperty("uv_scale", out vectorProperty))
            {
                uvScale.x = vectorProperty.x;
                uvScale.y = vectorProperty.y;
            }

            for (int i = 0; i < clips.Length; i++)
            {
                if (description.HasAnimationCurveInClip(clips[i].name, "uv_scale.x") ||
                    description.HasAnimationCurveInClip(clips[i].name, "uv_scale.y") ||
                    description.HasAnimationCurveInClip(clips[i].name, "uv_offset.x") ||
                    description.HasAnimationCurveInClip(clips[i].name, "uv_offset.y")
                    )
                {
                    if (description.TryGetAnimationCurve(clips[i].name, "uv_scale.x", out curve))
                    {
                        clips[i].SetCurve("", typeof(Material), "_MainTex_ST.x", curve);
                    }
                    else
                    {
                        clips[i].SetCurve("", typeof(Material), "_MainTex_ST.x", AnimationCurve.Constant(0.0f, 1.0f, 1.0f));
                    }

                    if (description.TryGetAnimationCurve(clips[i].name, "uv_scale.y", out curve))
                    {
                        clips[i].SetCurve("", typeof(Material), "_MainTex_ST.y", curve);
                    }
                    else
                    {
                        clips[i].SetCurve("", typeof(Material), "_MainTex_ST.y", AnimationCurve.Constant(0.0f, 1.0f, 1.0f));
                    }

                    if (description.TryGetAnimationCurve(clips[i].name, "uv_offset.x", out curve))
                    {
                        clips[i].SetCurve("", typeof(Material), "_MainTex_ST.z", curve);
                    }
                    else
                    {
                        clips[i].SetCurve("", typeof(Material), "_MainTex_ST.z", AnimationCurve.Constant(0.0f, 1.0f, 0.0f));
                    }

                    if (description.TryGetAnimationCurve(clips[i].name, "uv_offset.y", out curve))
                    {
                        ConvertKeys(curve, ConvertFloatNegate);
                        clips[i].SetCurve("", typeof(Material), "_MainTex_ST.w", curve);
                    }
                    else
                    {
                        clips[i].SetCurve("", typeof(Material), "_MainTex_ST.w", AnimationCurve.Constant(0.0f, 1.0f, 0.0f));
                    }
                }
            }

            float opacity        = 1.0f;
            float alphaThreshold = 0.0f;

            description.TryGetProperty("opacity", out opacity);
            description.TryGetProperty("mask_threshold", out alphaThreshold);
            if (alphaThreshold > 0.0f || description.HasAnimationCurve("mask_threshold"))
            {
                material.SetInt("_Mode", (int)StandardShaderGUI.BlendMode.Cutout);
                material.SetOverrideTag("RenderType", "TransparentCutout");
                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                material.SetInt("_ZWrite", 1);
                material.EnableKeyword("_ALPHATEST_ON");
                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
            }
            else if (opacity < 1.0f ||
                     description.HasAnimationCurve("opacity") ||
                     (description.TryGetProperty("use_opacity_map", out floatProperty) && floatProperty == 1.0f))
            {
                material.SetInt("_Mode", (int)StandardShaderGUI.BlendMode.Transparent);
                material.SetOverrideTag("RenderType", "Transparent");
                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                material.SetInt("_ZWrite", 0);
                material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
            }
            else
            {
                material.SetInt("_Mode", (int)StandardShaderGUI.BlendMode.Opaque);
                material.SetOverrideTag("RenderType", "");
                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;
            }

            if (description.TryGetProperty("use_color_map", out floatProperty) && floatProperty == 1.0f ||
                description.TryGetProperty("use_opacity_map", out floatProperty) && floatProperty == 1.0f)
            {
                if (description.TryGetProperty("TEX_color_map", out textureProperty))
                {
                    material.SetTexture("_MainTex", textureProperty.texture);
                    material.SetTextureOffset("_MainTex", uvOffset);
                    material.SetTextureScale("_MainTex", uvScale);
                    material.SetColor("_Color", new Vector4(1.0f, 1.0f, 1.0f, opacity));

                    if (alphaThreshold > 0.0f || description.HasAnimationCurve("mask_threshold"))
                    {
                        material.SetFloat("_Cutoff", alphaThreshold);
                        RemapCurve(description, clips, "mask_threshold", "_Cutoff");
                    }
                }
            }
            else
            {
                description.TryGetProperty("base_color", out vectorProperty);
                vectorProperty.w = opacity;
                material.SetColor("_Color", vectorProperty);
                RemapColorCurves(description, clips, "base_color", "_Color");
            }

            if (description.HasAnimationCurve("opacity"))
            {
                for (int i = 0; i < clips.Length; i++)
                {
                    AnimationCurve opacityCurve;
                    description.TryGetAnimationCurve(clips[i].name, "opacity", out opacityCurve);
                    clips[i].SetCurve("", typeof(Material), "_Color.a", opacityCurve);

                    if (!description.HasAnimationCurveInClip(clips[i].name, "base_color.x"))
                    {
                        Vector4 diffuseColor;
                        description.TryGetProperty("base_color", out diffuseColor);
                        clips[i].SetCurve("", typeof(Material), "_Color.r", AnimationCurve.Constant(0.0f, 1.0f, diffuseColor.x));
                        clips[i].SetCurve("", typeof(Material), "_Color.g", AnimationCurve.Constant(0.0f, 1.0f, diffuseColor.y));
                        clips[i].SetCurve("", typeof(Material), "_Color.b", AnimationCurve.Constant(0.0f, 1.0f, diffuseColor.z));
                    }
                }
            }

            if (description.TryGetProperty("use_normal_map", out floatProperty) && floatProperty == 1.0f)
            {
                if (description.TryGetProperty("TEX_normal_map", out textureProperty))
                {
                    material.SetTexture("_BumpMap", textureProperty.texture);
                    material.SetTextureOffset("_BumpMap", uvOffset);
                    material.SetTextureScale("_BumpMap", uvScale);
                    material.EnableKeyword("_NORMALMAP");
                }
            }

            if (description.TryGetProperty("use_metallic_map", out floatProperty) && floatProperty == 1.0f)
            {
                if (description.TryGetProperty("TEX_metallic_map", out textureProperty))
                {
                    material.SetTexture("_MetallicGlossMap", textureProperty.texture);
                    material.SetTextureOffset("_MetallicGlossMap", uvOffset);
                    material.SetTextureScale("_MetallicGlossMap", uvScale);
                    material.EnableKeyword("_METALLICGLOSSMAP");
                }
            }
            else
            {
                if (description.TryGetProperty("metallic", out floatProperty))
                {
                    material.SetFloat("_Metallic", floatProperty);
                    RemapCurve(description, clips, "metallic", "_Metallic");
                }
            }

            if (description.TryGetProperty("use_roughness_map", out floatProperty) && floatProperty == 1.0f)
            {
                if (description.TryGetProperty("TEX_roughness_map", out textureProperty))
                {
                    material.SetTexture("_SpecGlossMap", textureProperty.texture);
                    material.SetTextureOffset("_SpecGlossMap", uvOffset);
                    material.SetTextureScale("_SpecGlossMap", uvScale);
                    material.EnableKeyword("_SPECGLOSSMAP");
                }
            }
            else
            {
                if (description.TryGetProperty("roughness", out floatProperty))
                {
                    material.SetFloat("_Glossiness", floatProperty);
                    RemapCurve(description, clips, "roughness", "_Glossiness");
                }
            }

            if (description.TryGetProperty("use_emissive_map", out floatProperty) && floatProperty == 1.0f)
            {
                if (description.TryGetProperty("TEX_emissive_map", out textureProperty))
                {
                    Vector4 emissiveColor = new Vector4(1.0f, 1.0f, 1.0f, 1.0f);
                    if (description.TryGetProperty("emissive_intensity", out floatProperty))
                    {
                        emissiveColor *= floatProperty;
                    }
                    material.SetColor("_EmissionColor", emissiveColor);
                    material.SetTexture("_EmissionMap", textureProperty.texture);
                    material.SetTextureOffset("_EmissionMap", uvOffset);
                    material.SetTextureScale("_EmissionMap", uvScale);
                    material.EnableKeyword("_EMISSION");
                    material.globalIlluminationFlags |= MaterialGlobalIlluminationFlags.RealtimeEmissive;
                }

                if (description.HasAnimationCurve("emissive_intensity"))
                {
                    Vector4 emissiveColor;
                    description.TryGetProperty("emissive", out emissiveColor);

                    for (int i = 0; i < clips.Length; i++)
                    {
                        description.TryGetAnimationCurve(clips[i].name, "emissive_intensity", out curve);
                        // remap emissive intensity to emission color
                        clips[i].SetCurve("", typeof(Material), "_EmissionColor.r", curve);
                        clips[i].SetCurve("", typeof(Material), "_EmissionColor.g", curve);
                        clips[i].SetCurve("", typeof(Material), "_EmissionColor.b", curve);
                    }
                }
            }
            else if (description.TryGetProperty("emissive", out vectorProperty))
            {
                if (vectorProperty.x > 0.0f || vectorProperty.y > 0.0f || vectorProperty.z > 0.0f)
                {
                    material.globalIlluminationFlags |= MaterialGlobalIlluminationFlags.RealtimeEmissive;
                    material.EnableKeyword("_EMISSION");
                }

                if (description.TryGetProperty("emissive_intensity", out floatProperty))
                {
                    vectorProperty *= floatProperty;
                }

                material.SetColor("_EmissionColor", vectorProperty);


                if (description.HasAnimationCurve("emissive.x"))
                {
                    if (description.HasAnimationCurve("emissive_intensity"))
                    {
                        // combine color and intensity.
                        for (int i = 0; i < clips.Length; i++)
                        {
                            AnimationCurve intensityCurve;
                            description.TryGetAnimationCurve(clips[i].name, "emissive_intensity", out intensityCurve);

                            description.TryGetAnimationCurve(clips[i].name, "emissive.x", out curve);
                            MultiplyCurves(curve, intensityCurve);
                            clips[i].SetCurve("", typeof(Material), "_EmissionColor.r", curve);

                            description.TryGetAnimationCurve(clips[i].name, "emissive.y", out curve);
                            MultiplyCurves(curve, intensityCurve);
                            clips[i].SetCurve("", typeof(Material), "_EmissionColor.g", curve);

                            description.TryGetAnimationCurve(clips[i].name, "emissive.z", out curve);
                            MultiplyCurves(curve, intensityCurve);
                            clips[i].SetCurve("", typeof(Material), "_EmissionColor.b", curve);
                        }
                    }
                    else
                    {
                        RemapColorCurves(description, clips, "emissive", "_EmissionColor");
                    }
                }
                else if (description.HasAnimationCurve("emissive_intensity"))
                {
                    Vector4 emissiveColor;
                    description.TryGetProperty("emissive", out emissiveColor);

                    for (int i = 0; i < clips.Length; i++)
                    {
                        description.TryGetAnimationCurve(clips[i].name, "emissive_intensity", out curve);
                        // remap emissive intensity to emission color
                        AnimationCurve curveR = new AnimationCurve();
                        ConvertAndCopyKeys(curveR, curve, value => ConvertFloatMultiply(emissiveColor.x, value));
                        clips[i].SetCurve("", typeof(Material), "_EmissionColor.r", curveR);

                        AnimationCurve curveG = new AnimationCurve();
                        ConvertAndCopyKeys(curveG, curve, value => ConvertFloatMultiply(emissiveColor.y, value));
                        clips[i].SetCurve("", typeof(Material), "_EmissionColor.g", curveG);

                        AnimationCurve curveB = new AnimationCurve();
                        ConvertAndCopyKeys(curveB, curve, value => ConvertFloatMultiply(emissiveColor.z, value));
                        clips[i].SetCurve("", typeof(Material), "_EmissionColor.b", curveB);
                    }
                }
            }

            if (description.TryGetProperty("use_ao_map", out floatProperty) && floatProperty == 1.0f)
            {
                if (description.TryGetProperty("TEX_ao_map", out textureProperty))
                {
                    material.SetTexture("_OcclusionMap", textureProperty.texture);
                    material.SetTextureOffset("_OcclusionMap", uvOffset);
                    material.SetTextureScale("_OcclusionMap", uvScale);
                }
            }
        }
        void CreateFromMayaArnoldStandardSurfaceMaterial(MaterialDescription description, Material material, AnimationClip[] clips)
        {
            var shader = Shader.Find("Autodesk Interactive");

            if (shader == null)
            {
                context.LogImportError("FBXMaterialDescriptionPreprocessor cannot find a shader named 'Autodesk Interactive'.");
                return;
            }
            material.shader = shader;

            float   floatProperty;
            Vector4 vectorProperty;
            TexturePropertyDescription textureProperty;

            if (description.TryGetProperty("transmission", out floatProperty) && floatProperty > 0.0f)
            {
                material.SetInt("_Mode", (int)StandardShaderGUI.BlendMode.Transparent);
                material.SetOverrideTag("RenderType", "Transparent");
                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                material.SetInt("_ZWrite", 0);
                material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
            }
            else
            {
                material.SetInt("_Mode", (int)StandardShaderGUI.BlendMode.Opaque);
                material.SetOverrideTag("RenderType", "");
                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;
            }
            if (description.TryGetProperty("baseColor", out textureProperty))
            {
                SetMaterialTextureProperty("_MainTex", material, textureProperty);
                Color baseColor = new Color(1.0f, 1.0f, 1.0f, 1.0f - floatProperty);
                material.SetColor("_Color", baseColor);
            }
            else if (description.TryGetProperty("baseColor", out vectorProperty))
            {
                if (QualitySettings.activeColorSpace == ColorSpace.Gamma)
                {
                    vectorProperty.x = Mathf.LinearToGammaSpace(vectorProperty.x);
                    vectorProperty.y = Mathf.LinearToGammaSpace(vectorProperty.y);
                    vectorProperty.z = Mathf.LinearToGammaSpace(vectorProperty.z);
                }

                vectorProperty.w = 1.0f - floatProperty;
                material.SetColor("_Color", vectorProperty);

                RemapColorCurves(description, clips, "baseColor", "_Color");
            }

            if (description.HasAnimationCurve("transmission"))
            {
                for (int i = 0; i < clips.Length; i++)
                {
                    AnimationCurve opacityCurve;
                    description.TryGetAnimationCurve(clips[i].name, "transmission", out opacityCurve);
                    clips[i].SetCurve("", typeof(Material), "_Color.a", opacityCurve);

                    if (!description.HasAnimationCurveInClip(clips[i].name, "baseColor.x"))
                    {
                        Vector4 diffuseColor;
                        description.TryGetProperty("baseColor", out diffuseColor);
                        clips[i].SetCurve("", typeof(Material), "_Color.r", AnimationCurve.Constant(0.0f, 1.0f, diffuseColor.x));
                        clips[i].SetCurve("", typeof(Material), "_Color.g", AnimationCurve.Constant(0.0f, 1.0f, diffuseColor.y));
                        clips[i].SetCurve("", typeof(Material), "_Color.b", AnimationCurve.Constant(0.0f, 1.0f, diffuseColor.z));
                    }
                }
            }

            if (description.TryGetProperty("normalCamera", out textureProperty))
            {
                SetMaterialTextureProperty("_BumpMap", material, textureProperty);
                material.EnableKeyword("_NORMALMAP");
            }
            if (description.TryGetProperty("specularRoughness", out textureProperty))
            {
                SetMaterialTextureProperty("_SpecGlossMap", material, textureProperty);
                material.EnableKeyword("_SPECGLOSSMAP");
            }
            else if (description.TryGetProperty("specularRoughness", out floatProperty))
            {
                material.SetFloat("_Glossiness", floatProperty);
                RemapCurve(description, clips, "specularRoughness", "_Glossiness");
            }
            if (description.TryGetProperty("metalness", out textureProperty))
            {
                SetMaterialTextureProperty("_MetallicGlossMap", material, textureProperty);
                material.EnableKeyword("_METALLICGLOSSMAP");
                RemapCurve(description, clips, "metalness", "_MetallicGlossMap");
            }

            if (description.TryGetProperty("emission", out floatProperty) && floatProperty > 0.0f)
            {
                material.EnableKeyword("_EMISSION");
                material.globalIlluminationFlags |= MaterialGlobalIlluminationFlags.RealtimeEmissive;

                Color emissiveColor = new Color(1.0f, 1.0f, 1.0f, 1.0f);
                if (description.TryGetProperty("emissionColor", out textureProperty))
                {
                    emissiveColor *= floatProperty;
                    SetMaterialTextureProperty("_EmissionMap", material, textureProperty);
                    material.SetColor("_EmissionColor", emissiveColor);
                }
                else if (description.TryGetProperty("emissionColor", out vectorProperty))
                {
                    emissiveColor = vectorProperty * floatProperty;
                    material.SetColor("_EmissionColor", emissiveColor);
                }
            }

            if (description.HasAnimationCurve("emissionColor.x"))
            {
                if (description.HasAnimationCurve("emission"))
                {
                    // combine color and intensity.
                    AnimationCurve curve;
                    for (int i = 0; i < clips.Length; i++)
                    {
                        AnimationCurve intensityCurve;
                        description.TryGetAnimationCurve(clips[i].name, "emission", out intensityCurve);

                        description.TryGetAnimationCurve(clips[i].name, "emissionColor.x", out curve);
                        MultiplyCurves(curve, intensityCurve);
                        clips[i].SetCurve("", typeof(Material), "_EmissionColor.r", curve);

                        description.TryGetAnimationCurve(clips[i].name, "emissionColor.y", out curve);
                        MultiplyCurves(curve, intensityCurve);
                        clips[i].SetCurve("", typeof(Material), "_EmissionColor.g", curve);

                        description.TryGetAnimationCurve(clips[i].name, "emissionColor.z", out curve);
                        MultiplyCurves(curve, intensityCurve);
                        clips[i].SetCurve("", typeof(Material), "_EmissionColor.b", curve);
                    }
                }
                else
                {
                    RemapColorCurves(description, clips, "emission", "_EmissionColor");
                }
            }
            else if (description.HasAnimationCurve("emission"))
            {
                Vector4 emissiveColor;
                description.TryGetProperty("emissionColor", out emissiveColor);
                AnimationCurve curve;
                for (int i = 0; i < clips.Length; i++)
                {
                    description.TryGetAnimationCurve(clips[i].name, "emission", out curve);
                    // remap emissive intensity to emission color
                    AnimationCurve curveR = new AnimationCurve();
                    ConvertAndCopyKeys(curveR, curve, value => ConvertFloatMultiply(emissiveColor.x, value));
                    clips[i].SetCurve("", typeof(Material), "_EmissionColor.r", curveR);

                    AnimationCurve curveG = new AnimationCurve();
                    ConvertAndCopyKeys(curveG, curve, value => ConvertFloatMultiply(emissiveColor.y, value));
                    clips[i].SetCurve("", typeof(Material), "_EmissionColor.g", curveG);

                    AnimationCurve curveB = new AnimationCurve();
                    ConvertAndCopyKeys(curveB, curve, value => ConvertFloatMultiply(emissiveColor.z, value));
                    clips[i].SetCurve("", typeof(Material), "_EmissionColor.b", curveB);
                }
            }
        }