Function FillMaterial

code/AssetLib/IFC/IFCMaterial.cpp:70–127

------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
static void FillMaterial(aiMaterial* mat,const IFC::Schema_2x3::IfcSurfaceStyle* surf,ConversionData& conv) {
    aiString name;
    name.Set((surf->Name? surf->Name.Get() : "IfcSurfaceStyle_Unnamed"));
    mat->AddProperty(&name,AI_MATKEY_NAME);

    // now see which kinds of surface information are present
    for (const std::shared_ptr<const IFC::Schema_2x3::IfcSurfaceStyleElementSelect> &sel2 : surf->Styles) {
        if (const IFC::Schema_2x3::IfcSurfaceStyleShading* shade = sel2->ResolveSelectPtr<IFC::Schema_2x3::IfcSurfaceStyleShading>(conv.db)) {
            aiColor4D col_base,col;

            ConvertColor(col_base, shade->SurfaceColour);
            mat->AddProperty(&col_base,1, AI_MATKEY_COLOR_DIFFUSE);

            if (const IFC::Schema_2x3::IfcSurfaceStyleRendering* ren = shade->ToPtr<IFC::Schema_2x3::IfcSurfaceStyleRendering>()) {

                if (ren->Transparency) {
                    const float t = 1.f-static_cast<float>(ren->Transparency.Get());
                    mat->AddProperty(&t,1, AI_MATKEY_OPACITY);
                }

                if (ren->DiffuseColour) {
                    ConvertColor(col, *ren->DiffuseColour.Get(),conv,&col_base);
                    mat->AddProperty(&col,1, AI_MATKEY_COLOR_DIFFUSE);
                }

                if (ren->SpecularColour) {
                    ConvertColor(col, *ren->SpecularColour.Get(),conv,&col_base);
                    mat->AddProperty(&col,1, AI_MATKEY_COLOR_SPECULAR);
                }

                if (ren->TransmissionColour) {
                    ConvertColor(col, *ren->TransmissionColour.Get(),conv,&col_base);
                    mat->AddProperty(&col,1, AI_MATKEY_COLOR_TRANSPARENT);
                }

                if (ren->ReflectionColour) {
                    ConvertColor(col, *ren->ReflectionColour.Get(),conv,&col_base);
                    mat->AddProperty(&col,1, AI_MATKEY_COLOR_REFLECTIVE);
                }

                const int shading = (ren->SpecularHighlight && ren->SpecularColour)?ConvertShadingMode(ren->ReflectanceMethod):static_cast<int>(aiShadingMode_Gouraud);
                mat->AddProperty(&shading,1, AI_MATKEY_SHADING_MODEL);

                if (ren->SpecularHighlight) {
                    if(const ::Assimp::STEP::EXPRESS::REAL* rt = ren->SpecularHighlight.Get()->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
                        // at this point we don't distinguish between the two distinct ways of
                        // specifying highlight intensities. leave this to the user.
                        const float e = static_cast<float>(*rt);
                        mat->AddProperty(&e,1,AI_MATKEY_SHININESS);
                    }
                    else {
                        IFCImporter::LogWarn("unexpected type error, SpecularHighlight should be a REAL");
                    }
                }
            }
        }
    }
}