def draw(self, context): material = context.active_object.active_material mmd_material = material.mmd_material layout = self.layout fnMat = FnMaterial(material) col = layout.column() col.label(text='Texture:') r = col.row(align=True) tex = fnMat.get_texture() if tex: if tex.type == 'IMAGE' and tex.image: r.prop(tex.image, 'filepath', text='') r.operator('mmd_tools.material_remove_texture', text='', icon='PANEL_CLOSE') else: r.operator('mmd_tools.material_remove_texture', text='Remove', icon='PANEL_CLOSE') r.label(icon='ERROR') else: r.operator('mmd_tools.material_open_texture', text='Add', icon=ICON_FILE_FOLDER) col = layout.column() col.label(text='Sphere Texture:') r = col.row(align=True) tex = fnMat.get_sphere_texture() if tex: if tex.type == 'IMAGE' and tex.image: r.prop(tex.image, 'filepath', text='') r.operator('mmd_tools.material_remove_sphere_texture', text='', icon='PANEL_CLOSE') else: r.operator('mmd_tools.material_remove_sphere_texture', text='Remove', icon='PANEL_CLOSE') r.label(icon='ERROR') else: r.operator('mmd_tools.material_open_sphere_texture', text='Add', icon=ICON_FILE_FOLDER) col.row(align=True).prop(mmd_material, 'sphere_texture_type', expand=True) col = layout.column() row = col.row() row.prop(mmd_material, 'is_shared_toon_texture') r = row.row() r.active = mmd_material.is_shared_toon_texture r.prop(mmd_material, 'shared_toon_texture') r = col.row() r.active = not mmd_material.is_shared_toon_texture r.prop(mmd_material, 'toon_texture')
def __importMaterials(self): self.__importTextures() pmxModel = self.__model self.__materialFaceCountTable = [] for i in pmxModel.materials: mat = bpy.data.materials.new(name=self.__safe_name(i.name, max_length=50)) self.__materialTable.append(mat) mmd_mat = mat.mmd_material mmd_mat.name_j = i.name mmd_mat.name_e = i.name_e mmd_mat.ambient_color = i.ambient mmd_mat.diffuse_color = i.diffuse[0:3] mmd_mat.alpha = i.diffuse[3] mmd_mat.specular_color = i.specular mmd_mat.shininess = i.shininess mmd_mat.is_double_sided = i.is_double_sided mmd_mat.enabled_drop_shadow = i.enabled_drop_shadow mmd_mat.enabled_self_shadow_map = i.enabled_self_shadow_map mmd_mat.enabled_self_shadow = i.enabled_self_shadow mmd_mat.enabled_toon_edge = i.enabled_toon_edge mmd_mat.edge_color = i.edge_color mmd_mat.edge_weight = i.edge_size mmd_mat.sphere_texture_type = str(i.sphere_texture_mode) if i.is_shared_toon_texture: mmd_mat.is_shared_toon_texture = True mmd_mat.shared_toon_texture = i.toon_texture else: mmd_mat.is_shared_toon_texture = False if i.toon_texture >= 0: mmd_mat.toon_texture = self.__textureTable[i.toon_texture] else: mmd_mat.toon_texture = '' mmd_mat.comment = i.comment self.__materialFaceCountTable.append(int(i.vertex_count/3)) self.__meshObj.data.materials.append(mat) fnMat = FnMaterial(mat) if i.texture != -1: texture_slot = fnMat.create_texture(self.__textureTable[i.texture]) texture_slot.texture.use_mipmap = self.__use_mipmap self.__imageTable[len(self.__materialTable)-1] = texture_slot.texture.image if i.sphere_texture_mode == 2: amount = self.__spa_blend_factor else: amount = self.__sph_blend_factor if i.sphere_texture != -1 and amount != 0.0: texture_slot = fnMat.create_sphere_texture(self.__textureTable[i.sphere_texture]) texture_slot.diffuse_color_factor = amount if i.sphere_texture_mode == 3 and getattr(pmxModel.header, 'additional_uvs', 0): texture_slot.uv_layer = 'UV1' # for SubTexture mmd_mat.sphere_texture_type = mmd_mat.sphere_texture_type # re-update
def execute(self, context): obj = context.active_object current_idx = obj.active_material_index next_index = current_idx + 1 try: FnMaterial.swap_materials(obj, current_idx, next_index, reverse=True, swap_slots=True) except MaterialNotFoundError: self.report({'ERROR'}, 'Materials not found') return {'CANCELLED'} obj.active_material_index = next_index return {'FINISHED'}
def _set_material(prop, value): if value not in bpy.data.materials.keys(): prop['material_id'] = -1 return mat = bpy.data.materials[value] fnMat = FnMaterial(mat) prop['material_id'] = fnMat.material_id
def _get_material(prop): mat_id = prop.get('material_id') if mat_id < 0: return '' fnMat = FnMaterial.from_material_id(mat_id) if not fnMat: return '' return fnMat.material.name
def _toggleUseSphereTexture(self, context): root = self.id_data rig = mmd_model.Model(root) use_sphere = self.use_sphere_texture for i in rig.meshes(): for m in i.data.materials: if m is None: continue FnMaterial(m).use_sphere_texture(use_sphere, i)
def _update_material_morph_data(prop, context): if not prop.name.startswith('mmd_bind'): return from mmd_tools.core.shader import _MaterialMorph mat_id = prop.get('material_id', -1) if mat_id >= 0: mat = getattr(FnMaterial.from_material_id(mat_id), 'material', None) _MaterialMorph.update_morph_inputs(mat, prop) elif mat_id == -1: for mat in FnModel(prop.id_data).materials(): _MaterialMorph.update_morph_inputs(mat, prop)
def execute(self, context): obj = context.active_object root = mmd_model.Model.findRoot(obj) rig = mmd_model.Model(root) for meshObj in rig.meshes(): mats_to_delete = [] for mat in meshObj.data.materials: if mat and "_temp" in mat.name: mats_to_delete.append(mat) for temp_mat in reversed(mats_to_delete): base_mat_name = temp_mat.name.split('_temp')[0] try: FnMaterial.swap_materials(meshObj, temp_mat.name, base_mat_name) except MaterialNotFoundError: self.report({'WARNING'}, 'Base material for %s was not found' % temp_mat.name) else: temp_idx = meshObj.data.materials.find(temp_mat.name) mat = meshObj.data.materials.pop(index=temp_idx) if mat.users < 1: bpy.data.materials.remove(mat) return {'FINISHED'}
def _updateDiffuseColor(prop, context): FnMaterial(prop.id_data).update_diffuse_color()
def __importMaterials(self): self.__importTextures() pmxModel = self.__model self.__materialFaceCountTable = [] for i in pmxModel.materials: mat = bpy.data.materials.new(name=i.name) self.__materialTable.append(mat) mmd_mat = mat.mmd_material mat.diffuse_color = i.diffuse[0:3] mat.alpha = i.diffuse[3] mat.specular_color = i.specular[0:3] mat.specular_alpha = i.specular[3] mat.use_shadows = i.enabled_self_shadow mat.use_transparent_shadows = i.enabled_self_shadow mat.use_cast_buffer_shadows = i.enabled_self_shadow_map # only buffer shadows if hasattr(mat, 'use_cast_shadows'): # "use_cast_shadows" is not supported in older Blender (< 2.71), # so we still use "use_cast_buffer_shadows". mat.use_cast_shadows = i.enabled_self_shadow_map if mat.alpha < 1.0 or mat.specular_alpha < 1.0 or i.texture != -1: mat.use_transparency = True mat.transparency_method = 'Z_TRANSPARENCY' mmd_mat.name_j = i.name mmd_mat.name_e = i.name_e mmd_mat.ambient_color = i.ambient mmd_mat.is_double_sided = i.is_double_sided mmd_mat.enabled_drop_shadow = i.enabled_drop_shadow mmd_mat.enabled_self_shadow_map = i.enabled_self_shadow_map mmd_mat.enabled_self_shadow = i.enabled_self_shadow mmd_mat.enabled_toon_edge = i.enabled_toon_edge if (len(i.edge_color) == 4): # If it cames from PMD it will not # have edge color and assigning an empty array # will raise an error(ValueError) mmd_mat.edge_color = i.edge_color mmd_mat.edge_weight = i.edge_size mmd_mat.sphere_texture_type = str(i.sphere_texture_mode) if i.is_shared_toon_texture: mmd_mat.is_shared_toon_texture = True mmd_mat.shared_toon_texture = i.toon_texture else: mmd_mat.is_shared_toon_texture = False if i.toon_texture >= 0: mmd_mat.toon_texture = self.__textureTable[i.toon_texture] else: mmd_mat.toon_texture = '' mmd_mat.comment = i.comment self.__materialFaceCountTable.append(int(i.vertex_count / 3)) self.__meshObj.data.materials.append(mat) fnMat = FnMaterial(mat) if i.texture != -1: texture_slot = fnMat.create_texture( self.__textureTable[i.texture]) texture_slot.texture.use_mipmap = self.__use_mipmap if i.sphere_texture_mode == 2: amount = self.__spa_blend_factor blend = 'ADD' else: amount = self.__sph_blend_factor blend = 'MULTIPLY' if i.sphere_texture != -1 and amount != 0.0: texture_slot = fnMat.create_sphere_texture( self.__textureTable[i.sphere_texture]) if isinstance(texture_slot.texture.image, bpy.types.Image): texture_slot.texture.image.use_alpha = False texture_slot.diffuse_color_factor = amount texture_slot.blend_type = blend
def _updateAlpha(prop, context): FnMaterial(prop.id_data).update_alpha()
def _updateSpecularColor(prop, context): FnMaterial(prop.id_data).update_specular_color()
def execute(self, context): mat = context.active_object.active_material fnMat = FnMaterial(mat) fnMat.create_sphere_texture(self.filepath, context.active_object) return {'FINISHED'}
def _updateToonTexture(prop, context): FnMaterial(prop.id_data).update_toon_texture()
def execute(self, context): mat = context.active_object.active_material fnMat = FnMaterial(mat) fnMat.remove_sphere_texture() return {'FINISHED'}
def _updateIsDoubleSided(prop, context): FnMaterial(prop.id_data).update_is_double_sided()
def execute(self, context): obj = context.active_object root = mmd_model.Model.findRoot(obj) rig = mmd_model.Model(root) mmd_root = root.mmd_root morph = mmd_root.material_morphs[mmd_root.active_morph] mat_data = morph.data[morph.active_data] meshObj = rig.findMesh(mat_data.related_mesh) if meshObj is None: self.report({'ERROR'}, "The model mesh can't be found") return {'CANCELLED'} try: work_mat_name = mat_data.material + '_temp' work_mat, base_mat = FnMaterial.swap_materials( meshObj, work_mat_name, mat_data.material) except MaterialNotFoundError: self.report({'ERROR'}, "Material not found") return {'CANCELLED'} copy_idx = meshObj.data.materials.find(work_mat.name) base_mmd_mat = base_mat.mmd_material work_mmd_mat = work_mat.mmd_material if mat_data.offset_type == "MULT": try: diffuse_offset = divide_vector_components( work_mmd_mat.diffuse_color, base_mmd_mat.diffuse_color ) + [special_division(work_mmd_mat.alpha, base_mmd_mat.alpha)] specular_offset = divide_vector_components( work_mmd_mat.specular_color, base_mmd_mat.specular_color) edge_offset = divide_vector_components(work_mmd_mat.edge_color, base_mmd_mat.edge_color) mat_data.diffuse_color = diffuse_offset mat_data.specular_color = specular_offset mat_data.shininess = special_division(work_mmd_mat.shininess, base_mmd_mat.shininess) mat_data.ambient_color = divide_vector_components( work_mmd_mat.ambient_color, base_mmd_mat.ambient_color) mat_data.edge_color = edge_offset mat_data.edge_weight = special_division( work_mmd_mat.edge_weight, base_mmd_mat.edge_weight) except DivisionError: mat_data.offset_type = "ADD" # If there is any 0 division we automatically switch it to type ADD except ValueError: self.report({'ERROR'}, 'An unexpected error happened') # We should stop on our tracks and re-raise the exception raise if mat_data.offset_type == "ADD": diffuse_offset = list(work_mmd_mat.diffuse_color - base_mmd_mat.diffuse_color) + [ work_mmd_mat.alpha - base_mmd_mat.alpha ] specular_offset = list(work_mmd_mat.specular_color - base_mmd_mat.specular_color) edge_offset = Vector(work_mmd_mat.edge_color) - Vector( base_mmd_mat.edge_color) mat_data.diffuse_color = diffuse_offset mat_data.specular_color = specular_offset mat_data.shininess = work_mmd_mat.shininess - base_mmd_mat.shininess mat_data.ambient_color = work_mmd_mat.ambient_color - base_mmd_mat.ambient_color mat_data.edge_color = list(edge_offset) mat_data.edge_weight = work_mmd_mat.edge_weight - base_mmd_mat.edge_weight mat = meshObj.data.materials.pop(index=copy_idx) if mat.users < 1: bpy.data.materials.remove(mat) return {'FINISHED'}
def _updateEnabledToonEdge(prop, context): FnMaterial(prop.id_data).update_enabled_toon_edge()
def _updateSelfShadow(prop, context): FnMaterial(prop.id_data).update_self_shadow()
def _updateDropShadow(prop, context): FnMaterial(prop.id_data).update_drop_shadow()
def _updateAmbientColor(prop, context): FnMaterial(prop.id_data).update_ambient_color()
def _updateShininess(prop, context): FnMaterial(prop.id_data).update_shininess()
def execute(self, context): mat = context.active_object.active_material fnMat = FnMaterial(mat) fnMat.create_sphere_texture(self.filepath) return {'FINISHED'}
def execute(self, context): mat = context.active_object.active_material fnMat = FnMaterial(mat) fnMat.remove_texture() return {'FINISHED'}
def _updateEdgeColor(prop, context): FnMaterial(prop.id_data).update_edge_color()
def _updateSphereMapType(prop, context): FnMaterial(prop.id_data).update_sphere_texture_type(context.active_object)
def execute(self, context): obj = context.active_object root = mmd_model.Model.findRoot(obj) rig = mmd_model.Model(root) mmd_root = root.mmd_root morph = mmd_root.material_morphs[mmd_root.active_morph] mat_data = morph.data[morph.active_data] meshObj = rig.findMesh(mat_data.related_mesh) if meshObj is None: self.report({'ERROR'}, "The model mesh can't be found") return {'CANCELLED'} base_mat = meshObj.data.materials.get(mat_data.material, None) if base_mat is None: self.report({'ERROR'}, 'Material "%s" not found' % mat_data.material) return {'CANCELLED'} work_mat_name = base_mat.name + '_temp' if work_mat_name in bpy.data.materials: self.report({'ERROR'}, 'Temporary material "%s" is in use' % work_mat_name) return {'CANCELLED'} work_mat = base_mat.copy() work_mat.name = work_mat_name meshObj.data.materials.append(work_mat) FnMaterial.swap_materials(meshObj, base_mat.name, work_mat.name) base_mmd_mat = base_mat.mmd_material work_mmd_mat = work_mat.mmd_material work_mmd_mat.material_id = -1 # Apply the offsets if mat_data.offset_type == "MULT": diffuse_offset = multiply_vector_components( base_mmd_mat.diffuse_color, mat_data.diffuse_color[0:3]) specular_offset = multiply_vector_components( base_mmd_mat.specular_color, mat_data.specular_color) edge_offset = multiply_vector_components(base_mmd_mat.edge_color, mat_data.edge_color) ambient_offset = multiply_vector_components( base_mmd_mat.ambient_color, mat_data.ambient_color) work_mmd_mat.diffuse_color = diffuse_offset work_mmd_mat.alpha *= mat_data.diffuse_color[3] work_mmd_mat.specular_color = specular_offset work_mmd_mat.shininess *= mat_data.shininess work_mmd_mat.ambient_color = ambient_offset work_mmd_mat.edge_color = edge_offset work_mmd_mat.edge_weight *= mat_data.edge_weight elif mat_data.offset_type == "ADD": diffuse_offset = Vector(base_mmd_mat.diffuse_color) + Vector( mat_data.diffuse_color[0:3]) specular_offset = Vector(base_mmd_mat.specular_color) + Vector( mat_data.specular_color) edge_offset = Vector(base_mmd_mat.edge_color) + Vector( mat_data.edge_color) ambient_offset = Vector(base_mmd_mat.ambient_color) + Vector( mat_data.ambient_color) work_mmd_mat.diffuse_color = list(diffuse_offset) work_mmd_mat.alpha += mat_data.diffuse_color[3] work_mmd_mat.specular_color = list(specular_offset) work_mmd_mat.shininess += mat_data.shininess work_mmd_mat.ambient_color = list(ambient_offset) work_mmd_mat.edge_color = list(edge_offset) work_mmd_mat.edge_weight += mat_data.edge_weight return {'FINISHED'}
def _updateEdgeWeight(prop, context): FnMaterial(prop.id_data).update_edge_weight()
def __importMaterials(self): self.__importTextures() pmxModel = self.__model self.__materialFaceCountTable = [] for i in pmxModel.materials: mat = bpy.data.materials.new(name=i.name) self.__materialTable.append(mat) mmd_mat = mat.mmd_material mat.diffuse_color = i.diffuse[0:3] mat.alpha = i.diffuse[3] mat.specular_color = i.specular[0:3] mat.specular_alpha = i.specular[3] mat.use_shadows = i.enabled_self_shadow mat.use_transparent_shadows = i.enabled_self_shadow mat.use_cast_buffer_shadows = i.enabled_self_shadow_map # only buffer shadows if hasattr(mat, 'use_cast_shadows'): # "use_cast_shadows" is not supported in older Blender (< 2.71), # so we still use "use_cast_buffer_shadows". mat.use_cast_shadows = i.enabled_self_shadow_map if mat.alpha < 1.0 or mat.specular_alpha < 1.0 or i.texture != -1: mat.use_transparency = True mat.transparency_method = 'Z_TRANSPARENCY' mmd_mat.name_j = i.name mmd_mat.name_e = i.name_e mmd_mat.ambient_color = i.ambient mmd_mat.is_double_sided = i.is_double_sided mmd_mat.enabled_drop_shadow = i.enabled_drop_shadow mmd_mat.enabled_self_shadow_map = i.enabled_self_shadow_map mmd_mat.enabled_self_shadow = i.enabled_self_shadow mmd_mat.enabled_toon_edge = i.enabled_toon_edge if(len(i.edge_color)==4):# If it cames from PMD it will not # have edge color and assigning an empty array # will raise an error(ValueError) mmd_mat.edge_color = i.edge_color mmd_mat.edge_weight = i.edge_size mmd_mat.sphere_texture_type = str(i.sphere_texture_mode) if i.is_shared_toon_texture: mmd_mat.is_shared_toon_texture = True mmd_mat.shared_toon_texture = i.toon_texture else: mmd_mat.is_shared_toon_texture = False if i.toon_texture >= 0: mmd_mat.toon_texture = self.__textureTable[i.toon_texture] else: mmd_mat.toon_texture = '' mmd_mat.comment = i.comment self.__materialFaceCountTable.append(int(i.vertex_count/3)) self.__meshObj.data.materials.append(mat) fnMat = FnMaterial(mat) if i.texture != -1: texture_slot = fnMat.create_texture(self.__textureTable[i.texture]) texture_slot.texture.use_mipmap = self.__use_mipmap if i.sphere_texture_mode == 2: amount = self.__spa_blend_factor blend = 'ADD' else: amount = self.__sph_blend_factor blend = 'MULTIPLY' if i.sphere_texture != -1 and amount != 0.0: texture_slot = fnMat.create_sphere_texture(self.__textureTable[i.sphere_texture]) if isinstance(texture_slot.texture.image, bpy.types.Image): texture_slot.texture.image.use_alpha = False texture_slot.diffuse_color_factor = amount texture_slot.blend_type = blend
def __importMaterials(self): self.__importTextures() pmxModel = self.__model self.__materialFaceCountTable = [] for i in pmxModel.materials: mat = bpy.data.materials.new(name=i.name) self.__materialTable.append(mat) mmd_mat = mat.mmd_material mat.use_nodes = True mat.diffuse_color = i.diffuse[0:4] mat.specular_color = i.specular[0:3] mat.specular_intensity = i.specular[3] mat.shadow_method = 'HASHED' mat.blend_method = 'HASHED' mat.use_screen_refraction = True #mat.use_shadows = i.enabled_self_shadow #mat.use_transparent_shadows = i.enabled_self_shadow #mat.use_cast_buffer_shadows = i.enabled_self_shadow_map # only buffer shadows #if hasattr(mat, 'use_cast_shadows'): # "use_cast_shadows" is not supported in older Blender (< 2.71), # so we still use "use_cast_buffer_shadows". #mat.use_cast_shadows = i.enabled_self_shadow_map #if mat.alpha < 1.0 or mat.specular_alpha < 1.0 or i.texture != -1: #mat.use_transparency = True #mat.transparency_method = 'Z_TRANSPARENCY' #fit for cycles mat.node_tree.links.clear() shader = mat.node_tree.nodes['Principled BSDF'] #texture = None outplug = shader.outputs[0] mat.node_tree.links.new(mat.node_tree.nodes['Material Output'].inputs['Surface'], outplug) mat.node_tree.nodes['Material Output'].location.x = shader.location.x + 500 mat.node_tree.nodes['Material Output'].location.y = shader.location.y - 150 mmd_mat.name_j = i.name mmd_mat.name_e = i.name_e mmd_mat.ambient_color = i.ambient mmd_mat.is_double_sided = i.is_double_sided mmd_mat.enabled_drop_shadow = i.enabled_drop_shadow mmd_mat.enabled_self_shadow_map = i.enabled_self_shadow_map mmd_mat.enabled_self_shadow = i.enabled_self_shadow mmd_mat.enabled_toon_edge = i.enabled_toon_edge if(len(i.edge_color)==4):# If it cames from PMD it will not # have edge color and assigning an empty array # will raise an error(ValueError) mmd_mat.edge_color = i.edge_color mmd_mat.edge_weight = i.edge_size mmd_mat.sphere_texture_type = str(i.sphere_texture_mode) if i.is_shared_toon_texture: mmd_mat.is_shared_toon_texture = True mmd_mat.shared_toon_texture = i.toon_texture else: mmd_mat.is_shared_toon_texture = False if i.toon_texture >= 0: mmd_mat.toon_texture = self.__textureTable[i.toon_texture] else: mmd_mat.toon_texture = '' mmd_mat.comment = i.comment self.__materialFaceCountTable.append(int(i.vertex_count/3)) self.__meshObj.data.materials.append(mat) fnMat = FnMaterial(mat) if i.texture != -1: texnode = fnMat.create_texture(self.__textureTable[i.texture],shader) #texture_slot = fnMat.create_texture(self.__textureTable[i.texture]) #texture_slot.texture.use_mipmap = self.__use_mipmap mat.node_tree.links.new(shader.inputs['Base Color'], texnode.outputs['Color']) mat.node_tree.links.new(shader.inputs['Alpha'], texnode.outputs['Alpha']) '''