Mtl* FindOrCreateMaterial(MtlBaseLib* library, Interface* max_interface, int& slot, const IfcGeom::Material& material) { Mtl* m = FindMaterialByName(library, material.name()); if (m == 0) { StdMat2* stdm = NewDefaultStdMat(); const TimeValue t = -1; if (material.hasDiffuse()) { const double* diffuse = material.diffuse(); stdm->SetDiffuse(Color(diffuse[0], diffuse[1], diffuse[2]),t); } if (material.hasSpecular()) { const double* specular = material.specular(); stdm->SetSpecular(Color(specular[0], specular[1], specular[2]),t); } if (material.hasSpecularity()) { stdm->SetShininess(material.specularity(), t); } if (material.hasTransparency()) { stdm->SetOpacity(1.0 - material.transparency(), t); } m = stdm; m->SetName(S(material.name())); library->Add(m); if (slot < NUM_MATERIAL_SLOTS) { max_interface->PutMtlToMtlEditor(m,slot++); } } return m; }
void bhkProxyObject::CreateMesh() { if (Interface *gi = this->mIP) { if (const Mesh* pMesh = &this->proxyMesh) { if (TriObject *triObject = CreateNewTriObject()) { MNMesh mnmesh(*pMesh); Mesh& mesh = triObject->GetMesh(); mnmesh.OutToTri(mesh); INode *node = gi->CreateObjectNode(triObject); // Wireframe Red color StdMat2 *collMat = NewDefaultStdMat(); collMat->SetDiffuse(Color(1.0f, 0.0f, 0.0f), 0); collMat->SetWire(TRUE); collMat->SetFaceted(TRUE); gi->GetMaterialLibrary().Add(collMat); node->SetMtl(collMat); node->SetPrimaryVisibility(FALSE); node->SetSecondaryVisibility(FALSE); node->BoneAsLine(TRUE); node->SetRenderable(FALSE); node->SetWireColor( RGB(255,0,0) ); gi->SelectNode(node); } } } }
void M3Mat::Reset() { // char s[25]; DeleteReference(101); for(int i=0;i<100;i++) { DeleteReference(i); mTex[i] = NULL; // ReplaceReference(i,NewDefaultStdMat()); // sprintf(s,GetString(IDS_MTL_CNAME),i+1); // mTex[i]->SetName(s); } ReplaceReference(100,NewDefaultStdMat()); mTex[100]->SetName(GetString(IDS_MTL_BASE)); ParamBlockDescID *descVer = new ParamBlockDescID[101]; for(int x=0;x<100;x++){ ParamBlockDescID add; add.type=TYPE_FLOAT; add.user=NULL; add.animatable=TRUE; add.id=x; descVer[x] = add; } ParamBlockDescID add; add.type=TYPE_INT; add.user=NULL; add.animatable=FALSE; add.id=x; descVer[x] = add; // x == 100 we guess? IParamBlock *pblockMat = (IParamBlock*)CreateParameterBlock(descVer,101,1); ReplaceReference(101,pblockMat); //ReplaceReference(102,NULL); delete [] descVer; pblockMat->SetValue(100,0,0); // set param [100], the mystery param }
Mtl* ComposeMultiMaterial(std::map<std::vector<std::string>, Mtl*>& multi_mats, MtlBaseLib* library, Interface* max_interface, int& slot, const std::vector<IfcGeom::Material>& materials, const std::string& object_type, const std::vector<int>& material_ids) { std::vector<std::string> material_names; bool needs_default = std::find(material_ids.begin(), material_ids.end(), -1) != material_ids.end(); if (needs_default) { material_names.push_back(object_type); } for (auto it = materials.begin(); it != materials.end(); ++it) { material_names.push_back(it->name()); } Mtl* default_material = 0; if (needs_default) { default_material = FindMaterialByName(library, object_type); if (default_material == 0) { default_material = NewDefaultStdMat(); default_material->SetName(S(object_type)); library->Add(default_material); if (slot < NUM_MATERIAL_SLOTS) { max_interface->PutMtlToMtlEditor(default_material, slot++); } } } if (material_names.size() == 1) { if (needs_default) { return default_material; } else { return FindOrCreateMaterial(library, max_interface, slot, *materials.begin()); } } std::map<std::vector<std::string>, Mtl*>::const_iterator i = multi_mats.find(material_names); if (i != multi_mats.end()) { return i->second; } MultiMtl* multi_mat = NewDefaultMultiMtl(); multi_mat->SetNumSubMtls(material_names.size()); int mtl_id = 0; if (needs_default) { multi_mat->SetSubMtlAndName(mtl_id ++, default_material, default_material->GetName()); } for (auto it = materials.begin(); it != materials.end(); ++it) { Mtl* mtl = FindOrCreateMaterial(library, max_interface, slot, *it); multi_mat->SetSubMtl(mtl_id ++, mtl); } library->Add(multi_mat); if (slot < NUM_MATERIAL_SLOTS) { max_interface->PutMtlToMtlEditor(multi_mat,slot++); } multi_mats.insert(std::pair<std::vector<std::string>, Mtl*>(material_names, multi_mat)); return multi_mat; }
void Import::LoadMaterials (dScene& scene, MaterialCache& materialCache) { dScene::Iterator iter (scene); for (iter.Begin(); iter; iter ++) { dScene::dTreeNode* const materialNode = iter.GetNode(); dNodeInfo* const info = scene.GetInfoFromNode(materialNode); if (info->IsType(dMaterialNodeInfo::GetRttiType())) { MaterialProxi material; material.m_mtl = NewDefaultStdMat(); StdMat* const stdMtl = (StdMat*)material.m_mtl; dMaterialNodeInfo* const materialInfo = (dMaterialNodeInfo*) info; stdMtl->SetName(materialInfo->GetName()); dVector ambient (materialInfo->GetAmbientColor()); dVector difusse (materialInfo->GetDiffuseColor()); dVector specular (materialInfo->GetSpecularColor()); float shininess (materialInfo->GetShininess()); //float shininessStr (materialInfo->GetShinStr()); float transparency (materialInfo->GetOpacity()); stdMtl->SetAmbient(*((Point3*)&ambient), 0); stdMtl->SetDiffuse(*((Point3*)&difusse), 0); stdMtl->SetSpecular(*((Point3*)&specular), 0); stdMtl->SetShinStr(shininess / 100.0f, 0); stdMtl->SetOpacity(transparency, 0); if (materialInfo->GetDiffuseTextId() != -1) { dScene::dTreeNode* textNode = scene.FindTextureByTextId(materialNode, materialInfo->GetDiffuseTextId()); if (textNode) { _ASSERTE (textNode); // BitmapTex* bmtex; // const TCHAR* txtName; dTextureNodeInfo* textureInfo = (dTextureNodeInfo*) scene.GetInfoFromNode(textNode); TCHAR txtNameBuffer[256]; sprintf (txtNameBuffer, "%s/%s", m_path, textureInfo->GetPathName()); const TCHAR* txtName = txtNameBuffer; BitmapTex* bmtex = (BitmapTex*)NewDefaultBitmapTex(); bmtex->SetMapName((TCHAR*)txtName); txtName = textureInfo->GetPathName(); bmtex->SetName (txtName); bmtex->GetUVGen()->SetMapChannel(1); stdMtl->SetSubTexmap(ID_DI, bmtex); stdMtl->SetTexmapAmt(ID_DI, 1.0f, 0); stdMtl->EnableMap(ID_DI, TRUE); // const char* materialOpanacity = segment.m_opacityTextureName; // if (materialOpanacity[0]) { // BitmapTex* bmtex; // const TCHAR* txtName; // // txtName = segment.m_opacityPathName; // bmtex = (BitmapTex*)NewDefaultBitmapTex(); // bmtex->SetMapName((TCHAR*)txtName); // // txtName = materialName; // bmtex->SetName (txtName); // bmtex->GetUVGen()->SetMapChannel(2); // // stdMtl->SetSubTexmap(ID_OP, bmtex); // stdMtl->SetTexmapAmt(ID_OP, 1.0f, 0); // stdMtl->EnableMap(ID_OP, TRUE); // } // materialCache.AddMaterial(material, segment.m_textureName); } } materialCache.AddMaterial(material, materialInfo->GetId()); } } }
//------------------------------ StdMat2* MaterialCreator::createStandardMaterial( const COLLADAFW::EffectCommon& effectCommon, const String& name, const MaterialCreator::MaterialIdentifier& materialIdentifier ) { StdMat2* material = NewDefaultStdMat(); COLLADAFW::EffectCommon::ShaderType shaderType = effectCommon.getShaderType(); switch ( shaderType ) { case COLLADAFW::EffectCommon::SHADER_CONSTANT: material->SetFaceted(true); // BUG393: Max actually does not support a constant shader! case COLLADAFW::EffectCommon::SHADER_BLINN: material->SwitchShader(Class_ID(StandardMaterial::STD2_BLINN_SHADER_CLASS_ID, 0)); break; case COLLADAFW::EffectCommon::SHADER_LAMBERT: case COLLADAFW::EffectCommon::SHADER_PHONG: case COLLADAFW::EffectCommon::SHADER_UNKNOWN: default: material->SwitchShader(Class_ID(StandardMaterial::STD2_PHONG_CLASS_ID, 0)); break; } // Retrieve the shader parameter blocks Shader* materialShader = material->GetShader(); IParamBlock2* shaderParameters = (IParamBlock2*) materialShader->GetReference(0); IParamBlock2* extendedParameters = (IParamBlock2*) material->GetReference(StandardMaterial::EXTENDED_PB_REF); // Common material parameters material->SetName(name.c_str()); const COLLADAFW::ColorOrTexture& diffuse = effectCommon.getDiffuse(); if ( diffuse.isColor() ) material->SetDiffuse( toMaxColor(diffuse), 0); const COLLADAFW::ColorOrTexture& emission = effectCommon.getEmission(); if ( emission.isColor() ) { material->SetSelfIllumColorOn(TRUE); material->SetSelfIllumColor( toMaxColor(emission), 0); } else { material->SetSelfIllumColorOn(FALSE); material->SetSelfIllum( 0, 0 ); } float maxOpacity = 1; const COLLADAFW::ColorOrTexture& opacity = effectCommon.getOpacity(); if ( opacity.isColor() ) { const COLLADAFW::Color& opacityColor = opacity.getColor(); float averageTransparent = (float)(opacityColor.getRed() + opacityColor.getGreen() + opacityColor.getBlue())/3; maxOpacity = averageTransparent; } if ( getDocumentImporter()->getInvertTransparency() ) { maxOpacity = 1 - maxOpacity; } // Max seems to like to have opacity 0 for opacity textures if ( opacity.isTexture() ) { material->SetOpacity( 0, 0); } else { material->SetOpacity( maxOpacity, 0); } if (shaderType != COLLADAFW::EffectCommon::SHADER_CONSTANT && shaderType != COLLADAFW::EffectCommon::SHADER_UNKNOWN) { // Unlock the ambient and diffuse colors materialShader->SetLockAD(FALSE); materialShader->SetLockADTex(FALSE); material->LockAmbDiffTex(FALSE); material->SyncADTexLock(FALSE); // Lambert/Phong material parameters const COLLADAFW::ColorOrTexture& ambient = effectCommon.getAmbient(); if ( ambient.isColor() ) material->SetAmbient( toMaxColor(ambient), 0); } else { // Approximate constant shader, specular is the same color if ( diffuse.isColor() ) material->SetSpecular( toMaxColor(diffuse), 0 ); } const COLLADAFW::ColorOrTexture& specular = effectCommon.getSpecular(); const COLLADAFW::FloatOrParam& shininessFloatOrParam = effectCommon.getShininess(); float shininess = 1; if ( shininessFloatOrParam.getType() == COLLADAFW::FloatOrParam::FLOAT ) { shininess = shininessFloatOrParam.getFloatValue(); } if ( shaderType == COLLADAFW::EffectCommon::SHADER_PHONG || shaderType == COLLADAFW::EffectCommon::SHADER_BLINN) { // Phong material parameters if ( specular.isColor() ) material->SetSpecular( toMaxColor(specular), 0 ); material->SetShininess(ConversionFunctors::fromPercent(shininess), 0); material->SetShinStr(ConversionFunctors::fromPercent(shininess), 0); } //create and assign textures createAndAssignTexture( material, effectCommon, &COLLADAFW::EffectCommon::getAmbient, ID_AM, materialIdentifier.ambientMapChannel); createAndAssignTexture( material, effectCommon, &COLLADAFW::EffectCommon::getDiffuse, ID_DI, materialIdentifier.diffuseMapChannel); createAndAssignTexture( material, effectCommon, &COLLADAFW::EffectCommon::getSpecular, ID_SP, materialIdentifier.specularMapChannel); createAndAssignTexture( material, effectCommon, &COLLADAFW::EffectCommon::getEmission, ID_SI, materialIdentifier.emissionMapChannel); createAndAssignTexture( material, effectCommon, &COLLADAFW::EffectCommon::getOpacity, ID_OP, materialIdentifier.opacityMapChannel); return material; }