/// <summary>
            ///     To the helix material.
            /// </summary>
            /// <param name="material">The material.</param>
            /// <returns></returns>
            /// <exception cref="System.NotSupportedException">Shading Mode {material.ShadingMode}</exception>
            protected virtual KeyValuePair <global::Assimp.Material, MaterialCore> OnCreateHelixMaterial(global::Assimp.Material material)
            {
                MaterialCore core = null;

                if (!material.HasShadingMode)
                {
                    if (material.HasNonTextureProperty(GLTFMatKeys.AI_MATKEY_GLTF_METALLIC_FACTOR) ||
                        material.HasNonTextureProperty(GLTFMatKeys.AI_MATKEY_GLTF_ROUGHNESS_FACTOR) ||
                        material.HasNonTextureProperty(GLTFMatKeys.AI_MATKEY_GLTF_BASECOLOR_FACTOR))
                    {
                        material.ShadingMode = ShadingMode.Fresnel;
                    }
                    else if (material.HasColorSpecular || material.HasColorDiffuse || material.HasTextureDiffuse)
                    {
                        material.ShadingMode = ShadingMode.Blinn;
                    }
                    else
                    {
                        material.ShadingMode = ShadingMode.Gouraud;
                    }
                }

                var mode = material.ShadingMode;

                if (Configuration.ImportMaterialType != MaterialType.Auto)
                {
                    switch (Configuration.ImportMaterialType)
                    {
                    case MaterialType.BlinnPhong:
                        mode = ShadingMode.Blinn;
                        break;

                    case MaterialType.Diffuse:
                        mode = ShadingMode.Gouraud;
                        break;

                    case MaterialType.PBR:
                        mode = ShadingMode.Fresnel;
                        break;

                    case MaterialType.VertexColor:
                        core = new ColorMaterialCore();
                        break;

                    case MaterialType.Normal:
                        core = new NormalMaterialCore();
                        break;

                    case MaterialType.Position:
                        core = new PositionMaterialCore();
                        break;
                    }
                }
                if (core == null)
                {
                    switch (mode)
                    {
                    case ShadingMode.Blinn:
                    case ShadingMode.Phong:
                    case ShadingMode.None:
                        core = OnCreatePhongMaterial(material);
                        break;

                    case ShadingMode.CookTorrance:
                    case ShadingMode.Fresnel:
                    case ShadingMode.OrenNayar:
                        core = OnCreatePBRMaterial(material);
                        break;

                    case ShadingMode.Gouraud:
                        var diffuse = new DiffuseMaterialCore
                        {
                            DiffuseColor = material.ColorDiffuse.ToSharpDXColor4()
                        };
                        if (material.HasOpacity)
                        {
                            var c = diffuse.DiffuseColor;
                            c.Alpha = material.Opacity;
                            diffuse.DiffuseColor = c;
                        }

                        if (material.HasTextureDiffuse)
                        {
                            diffuse.DiffuseMap         = LoadTexture(material.TextureDiffuse.FilePath);
                            diffuse.DiffuseMapFilePath = material.TextureDiffuse.FilePath;
                        }
                        if (material.ShadingMode == ShadingMode.Flat)
                        {
                            diffuse.EnableFlatShading = true;
                        }
                        core = diffuse;
                        break;

                    case ShadingMode.Flat:
                        core = OnCreatePhongMaterial(material);
                        if (core is PhongMaterialCore p)
                        {
                            p.EnableFlatShading = true;
                        }
                        break;

                    default:
                        switch (Configuration.ImportMaterialType)
                        {
                        case MaterialType.Position:
                            core = new PositionMaterialCore();
                            break;

                        case MaterialType.Normal:
                            core = new NormalMaterialCore();
                            break;

                        default:
                            Log(HelixToolkit.Logger.LogLevel.Warning, $"Shading Mode is not supported:{material.ShadingMode}");
                            core = new DiffuseMaterialCore()
                            {
                                DiffuseColor = Color.Red, EnableUnLit = true
                            };
                            break;
                        }
                        break;
                    }
                }

                if (core != null)
                {
                    core.Name = string.IsNullOrEmpty(material.Name) ? $"Material_{Interlocked.Increment(ref MaterialIndexForNoName)}" : material.Name;
                }
                return(new KeyValuePair <global::Assimp.Material, MaterialCore>(material, core));
            }
예제 #2
0
 public VertColorMaterial(ColorMaterialCore core) : base(core)
 {
 }