From 9079bf1bb3d8e4beeff5f3b37d496f87e1a094cc Mon Sep 17 00:00:00 2001 From: yyc12345 Date: Mon, 23 Oct 2023 10:57:29 +0800 Subject: [PATCH] remove uv modifier from bld_mesh.py and finish flatten uv and rail uv --- bbp_ng/OP_UV_flatten_uv.py | 132 ++++++++++++++-------- bbp_ng/OP_UV_rail_uv.py | 213 +++++++++++++++++++++++++++++++++++ bbp_ng/UTIL_blender_mesh.py | 103 +---------------- bbp_ng/UTIL_icons_manager.py | 7 ++ bbp_ng/__init__.py | 6 +- 5 files changed, 308 insertions(+), 153 deletions(-) create mode 100644 bbp_ng/UTIL_icons_manager.py diff --git a/bbp_ng/OP_UV_flatten_uv.py b/bbp_ng/OP_UV_flatten_uv.py index 388f66d..8a5d0b2 100644 --- a/bbp_ng/OP_UV_flatten_uv.py +++ b/bbp_ng/OP_UV_flatten_uv.py @@ -1,4 +1,7 @@ import bpy, mathutils, bmesh +from . import UTIL_virtools_types + +#region Param Struct class _FlattenParamBySize(): mScaleSize: float @@ -30,6 +33,8 @@ class _FlattenParam(): def CreateByRefPoint(cls, ref_point: int, ref_point_uv: float): return cls(True, _FlattenParamByRefPoint(ref_point, ref_point_uv)) +#endregion + class BBP_OT_flatten_uv(bpy.types.Operator): """Flatten selected face UV. Only works for convex face""" bl_idname = "bbp.flatten_uv" @@ -102,8 +107,15 @@ class BBP_OT_flatten_uv(bpy.types.Operator): scale_data: _FlattenParam = _FlattenParam.CreateByRefPoint(self.reference_point, self.reference_uv) # do flatten uv and report - no_processed_count = _real_flatten_uv(bpy.context.active_object.data, - self.reference_edge, scale_data) + # sync data first + # ref: https://blender.stackexchange.com/questions/218086/data-vertices-returns-an-empty-collection-in-edit-mode + this_obj: bpy.types.Object = bpy.context.active_object + this_obj.update_from_editmode() + no_processed_count = _real_flatten_uv( + this_obj.data, + self.reference_edge, + scale_data + ) if no_processed_count != 0: print("[Flatten UV] {} faces are not be processed correctly because process failed." .format(no_processed_count)) @@ -127,39 +139,72 @@ class BBP_OT_flatten_uv(bpy.types.Operator): layout.prop(self, "reference_point") layout.prop(self, "reference_uv") -def _real_flatten_uv(mesh: bpy.types.Mesh, reference_edge: int, - scale_data: _FlattenParam) -> int: +#region Real Worker Functions + +def _set_face_vertex_uv(face: bmesh.types.BMFace, uv_layer: bmesh.types.BMLayerItem, idx: int, uv: UTIL_virtools_types.ConstVxVector2) -> None: + """ + Help function to set UV data for face. + + @param face[in] The face to be set. + @param uv_layer[in] The corresponding uv layer. Hint: it was gotten from BMesh.loops.layers.uv.verify() + @param idx[in] The index of trying setting vertex. + @param uv[in] The set UV data + """ + face.loops[idx][uv_layer].uv = uv + +def _get_face_vertex_pos(face: bmesh.types.BMFace, idx: int) -> UTIL_virtools_types.ConstVxVector3: + """ + Help function to get vertex position from face by provided index. + No index overflow checker. Caller must make sure the provided index is not overflow. + + @param face[in] Bmesh face struct. + @param idx[in] The index of trying getting vertex. + @return The gotten vertex position. + """ + v: mathutils.Vector = face.loops[idx].vert.co + return (v[0], v[1], v[2]) + +def _circular_clamp_index(v: int, vmax: int) -> int: + """ + Circular clamp face vertex index. + Used by _real_flatten_uv. + + @param v[in] The index to clamp + @param vmax[in] The count of used face vertex. At least 3. + @return The circular clamped value ranging from 0 to vmax. + """ + return v % vmax + +def _real_flatten_uv(mesh: bpy.types.Mesh, reference_edge: int, scale_data: _FlattenParam) -> int: no_processed_count: int = 0 - # if no uv, create it - if mesh.uv_layers.active is None: - mesh.uv_layers.new(do_init = False) - - # create bmesh + # create bmesh modifier bm: bmesh.types.BMesh = bmesh.from_edit_mesh(mesh) - # NOTE: Blender 3.5 change mesh underlying data struct. - # Originally this section also need to be update ad Blender 3.5 style - # But this is a part of bmesh. This struct is not changed so we don't need update it. - uv_lay: bmesh.types.BMLayerItem = bm.loops.layers.uv.active + # use verify() to make sure there is a uv layer to write data + # verify() will return existing one or create one if no layer existing. + uv_layers: bmesh.types.BMLayerCollection = bm.loops.layers.uv + uv_layer: bmesh.types.BMLayerItem = uv_layers.verify() + # process each face face: bmesh.types.BMFace for face in bm.faces: - # ========== only process selected face ========== + # ===== check requirement ===== + # check whether face selected + # only process selected face if not face.select: continue - # ========== resolve reference edge and point ========== + # ===== resolve reference edge and point ===== # check reference validation - allPoint: int = len(face.loops) - if reference_edge >= allPoint: # reference edge overflow + all_point: int = len(face.loops) + if reference_edge >= all_point: # reference edge overflow no_processed_count += 1 continue # check scale validation if scale_data.mUseRefPoint: if ((scale_data.mParamData.mReferencePoint <= 1) # reference point too low - or (scale_data.mParamData.mReferencePoint - >= allPoint)): # reference point overflow + or (scale_data.mParamData.mReferencePoint >= all_point)): # reference point overflow no_processed_count += 1 continue else: @@ -181,20 +226,10 @@ def _real_flatten_uv(mesh: bpy.types.Mesh, reference_edge: int, # just a weird uv. user will notice this problem. # get point - p1Relative: int = reference_edge - p2Relative: int = reference_edge + 1 - p3Relative: int = reference_edge + 2 - if p2Relative >= allPoint: - p2Relative -= allPoint - if p3Relative >= allPoint: - p3Relative -= allPoint - - p1: mathutils.Vector = mathutils.Vector( - tuple(face.loops[p1Relative].vert.co[x] for x in range(3))) - p2: mathutils.Vector = mathutils.Vector( - tuple(face.loops[p2Relative].vert.co[x] for x in range(3))) - p3: mathutils.Vector = mathutils.Vector( - tuple(face.loops[p3Relative].vert.co[x] for x in range(3))) + pidx_start: int = _circular_clamp_index(reference_edge, all_point) + p1: mathutils.Vector = mathutils.Vector(_get_face_vertex_pos(face, pidx_start)) + p2: mathutils.Vector = mathutils.Vector(_get_face_vertex_pos(face, _circular_clamp_index(reference_edge + 1, all_point))) + p3: mathutils.Vector = mathutils.Vector(_get_face_vertex_pos(face, _circular_clamp_index(reference_edge + 2, all_point))) # get y axis new_y_axis: mathutils.Vector = p2 - p1 @@ -205,8 +240,7 @@ def _real_flatten_uv(mesh: bpy.types.Mesh, reference_edge: int, # get z axis new_z_axis: mathutils.Vector = new_y_axis.cross(vec1) new_z_axis.normalize() - if not any(round(v, 7) for v in new_z_axis - ): # if z is a zero vector, use face normal instead + if not any(round(v, 7) for v in new_z_axis): # if z is a zero vector, use face normal instead new_z_axis = face.normal.normalized() # get x axis @@ -228,25 +262,24 @@ def _real_flatten_uv(mesh: bpy.types.Mesh, reference_edge: int, transition_matrix: mathutils.Matrix = origin_base @ new_base transition_matrix.invert_safe() - # ========== rescale correction ========== + # ===== rescale correction ===== + rescale: float = 0.0 if scale_data.mUseRefPoint: # ref point method # get reference point from loop - refpRelative: int = p1Relative + scale_data.mParamData.mReferencePoint - if refpRelative >= allPoint: - refpRelative -= allPoint - pRef: mathutils.Vector = mathutils.Vector(tuple(face.loops[refpRelative].vert.co[x] for x in range(3))) - p1 + pidx_refp: int = _circular_clamp_index(pidx_start + scale_data.mParamData.mReferencePoint, all_point) + pref: mathutils.Vector = mathutils.Vector(_get_face_vertex_pos(face, pidx_refp)) - p1 # calc its U component - vec_u: float = abs((transition_matrix @ pRef).x) + vec_u: float = abs((transition_matrix @ pref).x) if round(vec_u, 7) == 0.0: - rescale: float = 1.0 # fallback. rescale = 1 will not affect anything + rescale = 1.0 # fallback. rescale = 1 will not affect anything else: - rescale: float = scale_data.mParamData.mReferenceUV / vec_u + rescale = scale_data.mParamData.mReferenceUV / vec_u else: # scale size method # apply rescale directly - rescale: float = 1.0 / scale_data.mParamData.mScaleSize + rescale = 1.0 / scale_data.mParamData.mScaleSize # construct matrix # we only rescale U component (X component) @@ -260,18 +293,19 @@ def _real_flatten_uv(mesh: bpy.types.Mesh, reference_edge: int, rescale_transition_matrix: mathutils.Matrix = scale_matrix @ transition_matrix # ========== process each face ========== - for loop_index in range(allPoint): - pp: mathutils.Vector = mathutils.Vector(tuple(face.loops[loop_index].vert.co[x] for x in range(3))) - p1 + for idx in range(all_point): + pp: mathutils.Vector = mathutils.Vector(_get_face_vertex_pos(face, idx)) - p1 ppuv: mathutils.Vector = rescale_transition_matrix @ pp # u and v component has been calculated properly. no extra process needed. # just get abs for the u component - face.loops[loop_index][uv_lay].uv = (abs(ppuv.x), ppuv.y) + _set_face_vertex_uv(face, uv_layer, idx, (abs(ppuv.x), ppuv.y)) - # sync the result to view port - bmesh.update_edit_mesh(mesh) + # return process result return no_processed_count +#endregion + def register() -> None: bpy.utils.register_class(BBP_OT_flatten_uv) diff --git a/bbp_ng/OP_UV_rail_uv.py b/bbp_ng/OP_UV_rail_uv.py index e69de29..2335453 100644 --- a/bbp_ng/OP_UV_rail_uv.py +++ b/bbp_ng/OP_UV_rail_uv.py @@ -0,0 +1,213 @@ +import bpy, bmesh, mathutils +import typing +from . import UTIL_virtools_types, UTIL_icons_manager, UTIL_functions + +#region Material Pointer Property Resolver + +class BBPRailUVPatch(bpy.types.PropertyGroup): + rail_mtl: bpy.props.PointerProperty( + name = "Material", + description = "The material used for rail", + type = bpy.types.Material, + ) + +def get_rail_uv_patch() -> BBPRailUVPatch: + return bpy.context.scene.bbp_rail_uv_patch + +def get_raw_rail_uv_patch() -> bpy.types.Material: + return get_rail_uv_patch().rail_mtl + +def draw_rail_uv_patch(layout: bpy.types.UILayout) -> None: + layout.prop(get_rail_uv_patch(), 'rail_mtl') + +#endregion + +class BBP_OT_rail_uv(bpy.types.Operator): + """Create UV for Rail as Ballance Showen (TT_ReflectionMapping)""" + bl_idname = "bbp.rail_uv" + bl_label = "Create Rail UV" + bl_options = {'UNDO'} + + @classmethod + def poll(self, context): + return _check_rail_target() + + def invoke(self, context, event): + wm: bpy.types.WindowManager = context.window_manager + return wm.invoke_props_dialog(self) + + def execute(self, context): + # check material + mtl: bpy.types.Material = get_raw_rail_uv_patch() + if mtl is None: + UTIL_functions.message_box( + ("No specific material", ), + "Lost Parameter", + UTIL_icons_manager.BlenderPresetIcons.Error.value + ) + return {'CANCELLED'} + + # apply rail uv + _create_rail_uv(_get_rail_target(), mtl) + return {'FINISHED'} + + def draw(self, context): + layout: bpy.types.UILayout = self.layout + draw_rail_uv_patch(layout) + +#region Real Worker Functions + +def _check_rail_target() -> bool: + for obj in bpy.context.selected_objects: + if obj.type != 'MESH': + continue + if obj.mode != 'OBJECT': + continue + if obj.data is None: + continue + return True + return False + +def _get_rail_target() -> typing.Iterable[bpy.types.Mesh]: + # collect objects + meshes: list[bpy.types.Mesh] = [] + error_objname: list[str] = [] + for obj in bpy.context.selected_objects: + if obj.type != 'MESH': + error_objname.append(obj.name) + continue + if obj.mode != 'OBJECT': + error_objname.append(obj.name) + continue + if obj.data is None: + error_objname.append(obj.name) + continue + + meshes.append(obj.data) + + # display warning window if necessary + if len(error_objname) != 0: + # show dialog + UTIL_functions.message_box( + ("Some objects is not processed, see Console for more infos.", ), + "Object Type Warning", + UTIL_icons_manager.BlenderPresetIcons.Warning.value + ) + + # output to console + print('') + print('=====') + print('Following objects are not processed by Rail UV because they do not meet the requirements of Rail UV.') + for objname in error_objname: + print(objname) + print('=====') + print('') + + # return valid + return meshes + +def _tt_reflection_mapping_compute( + point_: UTIL_virtools_types.ConstVxVector3, + nml_: UTIL_virtools_types.ConstVxVector3, + refobj_: UTIL_virtools_types.ConstVxVector3) -> UTIL_virtools_types.ConstVxVector2: + # switch blender coord to virtools coord for convenient calc + point: mathutils.Vector = mathutils.Vector((point_[0], point_[2], point_[1])) + nml: mathutils.Vector = mathutils.Vector((nml_[0], nml_[2], nml_[1])).normalized() + refobj: mathutils.Vector = mathutils.Vector((refobj_[0], refobj_[2], refobj_[1])) + + p: mathutils.Vector = (refobj - point).normalized() + b: mathutils.Vector = (((2 * (p * nml)) * nml) - p) + b.normalize() + + # convert back to blender coord + return ((b.x + 1.0) / 2.0, -(b.z + 1.0) / 2.0) + + +def _set_face_vertex_uv(face: bpy.types.MeshPolygon, uv_layer: bpy.types.MeshUVLoopLayer, idx: int, uv: UTIL_virtools_types.ConstVxVector2) -> None: + """ + Help function to set face vertex uv by index. + + @param face[in] The face to be set. + @param uv_layer[in] The uv layer to be set gotten from `Mesh.uv_layers.active` + @param idx[in] The index related to face to set uv. + @param uv[in] The uv data. + """ + uv_layer.uv[face.loop_start + idx].vector = uv + +def _get_face_vertex_pos(face: bpy.types.MeshPolygon, loops: bpy.types.MeshLoops, vecs: bpy.types.MeshVertices, idx: int) -> UTIL_virtools_types.ConstVxVector3: + """ + Help function. Get face referenced vertex position data by index + + @param face[in] The face to be set. + @param loops[in] Mesh loops gotten from `Mesh.loops` + @param vecs[in] Mesh vertices gotten from `Mesh.vertices` + @param idx[in] The index related to face to get position. + """ + v: mathutils.Vector = vecs[loops[face.loop_start + idx].vertex_index].co + return (v[0], v[1], v[2]) + +def _get_face_vertex_nml(face: bpy.types.MeshPolygon, loops: bpy.types.MeshLoops, idx: int) -> UTIL_virtools_types.ConstVxVector3: + """ + Help function to get face vertex normal. + + Similar to _get_face_vertex_pos, just get normal, not position. + + @param face[in] The face to be set. + @param loops[in] Mesh loops gotten from `Mesh.loops` + @param idx[in] The index related to face to get normal. + """ + v: mathutils.Vector = loops[face.loop_start + idx].normal + return (v[0], v[1], v[2]) + +def _get_face_vertex_count(face: bpy.types.MeshPolygon) -> int: + """ + Help function to get how many vertex used by this face. + + @return The count of used vertex. At least 3. + """ + return face.loop_total + +def _create_rail_uv(meshes: typing.Iterable[bpy.types.Mesh], mtl: bpy.types.Material): + for mesh in meshes: + # clean it material and set rail first + mesh.materials.clear() + mesh.materials.append(mtl) + # and validate face mtl idx ref + mesh.validate_material_indices() + + # get uv and make sure at least one uv + if mesh.uv_layers.active is None: + mesh.uv_layers.new(do_init = False) + uv_layer: bpy.types.MeshUVLoopLayer = mesh.uv_layers.active + # get other useful data + loops: bpy.types.MeshLoops = mesh.loops + vecs: bpy.types.MeshVertices = mesh.vertices + + refobj: UTIL_virtools_types.ConstVxVector3 = (0.0, 0.0, 0.0) + for face in mesh.polygons: + for idx in range(_get_face_vertex_count(face)): + _set_face_vertex_uv( + face, + uv_layer, + idx, + _tt_reflection_mapping_compute( + _get_face_vertex_pos(face, loops, vecs, idx), + _get_face_vertex_nml(face, loops, idx), + refobj + ) + ) + +#endregion + +def register() -> None: + # register patch first + bpy.utils.register_class(BBPRailUVPatch) + bpy.types.Scene.bbp_rail_uv_patch = bpy.props.PointerProperty(type = BBPRailUVPatch) + + bpy.utils.register_class(BBP_OT_rail_uv) + +def unregister() -> None: + del bpy.types.Scene.bbp_rail_uv_patch + + bpy.utils.unregister_class(BBP_OT_rail_uv) + diff --git a/bbp_ng/UTIL_blender_mesh.py b/bbp_ng/UTIL_blender_mesh.py index 63edcdc..434b42b 100644 --- a/bbp_ng/UTIL_blender_mesh.py +++ b/bbp_ng/UTIL_blender_mesh.py @@ -103,58 +103,6 @@ class TemporaryMesh(): raise UTIL_functions.BBPException('try calling invalid TemporaryMesh.') return self.__mTempMesh -class FaceForModifyingUV(): - """ - This class do not have invalid mesh exception checker. - Because MeshUVModifier will make sure this sub class will not throw any error - """ - - __mMeshVertices: bpy.types.MeshVertices - __mMeshUVs: bpy.types.MeshUVLoopLayer - __mMeshLoops: bpy.types.MeshLoops - __mMeshPolygon: bpy.types.MeshPolygon - - def __init__(self, mesh: bpy.types.Mesh): - self.__mMeshVertices = mesh.vertices - self.__mMeshUVs = mesh.uv_layers.active - self.__mMeshLoops = mesh.loops - - def _set_face(self, poly: bpy.types.MeshPolygon) -> None: - """ - Only should be called by MeshUVModifier - """ - self.__mMeshPolygon = poly - - def is_face_selected(self) -> bool: - return self.__mMeshPolygon.select - - def get_face_normal(self) -> UTIL_virtools_types.ConstVxVector3: - nml: mathutils.Vector = self.__mMeshPolygon.normal - return (nml.x, nml.y, nml.z) - - def get_face_vertex_count(self) -> int: - return self.__mMeshPolygon.loop_total - - def get_face_vertex_pos_by_index(self, index: int) -> UTIL_virtools_types.ConstVxVector3: - if index < 0 or index >= self.__mMeshPolygon.loop_total: - raise UTIL_functions.BBPException('invalid index for getting face vertex position.') - - v: mathutils.Vector = self.__mMeshVertices[self.__mMeshPolygon.loop_start + index].co - return (v.x, v.y, v.z) - - def get_face_vertex_nml_by_index(self, index: int) -> UTIL_virtools_types.ConstVxVector3: - if index < 0 or index >= self.__mMeshPolygon.loop_total: - raise UTIL_functions.BBPException('invalid index for getting face vertex position.') - - v: mathutils.Vector = self.__mMeshLoops[self.__mMeshPolygon.loop_start + index].normal - return (v.x, v.y, v.z) - - def set_face_vertex_uv_by_index(self, index: int, v: UTIL_virtools_types.ConstVxVector2) -> None: - if index < 0 or index >= self.__mMeshPolygon.loop_total: - raise UTIL_functions.BBPException('invalid index for getting face vertex position.') - - self.__mMeshUVs.uv[self.__mMeshPolygon.loop_start + index].vector = (v[0], v[1]) - #endregion class MeshReader(): @@ -495,7 +443,7 @@ class MeshWriter(): list(_flat_face_nml_index(self.__mFaceNmlIndices, self.__mVertexNormal)) ) # add face vertex uv by function - self.__mAssocMesh.uv_layers[0].uv.foreach_set('vector', + self.__mAssocMesh.uv_layers.active.uv.foreach_set('vector', list(_flat_face_uv_index(self.__mFaceUvIndices, self.__mVertexUV)) ) # NOTE: blender 3.5 changed. UV must be visited by .uv, not the .data @@ -540,52 +488,3 @@ class MeshWriter(): self.__mAssocMesh.clear_geometry() # clear mtl slot because clear_geometry will not do this. self.__mAssocMesh.materials.clear() - -class MeshUVModifier(): - """ - - """ - - __mAssocMesh: bpy.types.Mesh | None - - def __init__(self, mesh: bpy.types.Mesh): - self.__mAssocMesh = mesh - - if self.is_valid(): - # make sure there is a exist uv layer for editing - if self.__mAssocMesh.uv_layers.active is None: - self.__mAssocMesh.uv_layers.new(do_init = False) - - # split face normal - self.__mAssocMesh.calc_normals_split() - - def is_valid(self) -> bool: - return self.__mAssocMesh is not None - - def __enter__(self): - return self - - def __exit__(self, exc_type, exc_value, traceback): - self.dispose() - - def dispose(self) -> None: - if self.is_valid(): - # free split normal - self.__mAssocMesh.free_normals_split() - # free variable - self.__mAssocMesh = None - - def get_face_count(self) -> int: - if not self.is_valid(): - raise UTIL_functions.BBPException('try to call an invalid MeshUVModifier.') - - return len(self.__mAssocMesh.polygons) - - def get_face(self) -> typing.Iterator[FaceForModifyingUV]: - if not self.is_valid(): - raise UTIL_functions.BBPException('try to call an invalid MeshUVModifier.') - - cache: FaceForModifyingUV = FaceForModifyingUV(self.__mAssocMesh) - for poly in self.__mAssocMesh.polygons: - cache._set_face(poly) - yield cache diff --git a/bbp_ng/UTIL_icons_manager.py b/bbp_ng/UTIL_icons_manager.py new file mode 100644 index 0000000..3d366e1 --- /dev/null +++ b/bbp_ng/UTIL_icons_manager.py @@ -0,0 +1,7 @@ +import bpy +import os, enum + +class BlenderPresetIcons(enum.Enum): + Info = 'INFO' + Warning = 'ERROR' + Error = 'CANCEL' diff --git a/bbp_ng/__init__.py b/bbp_ng/__init__.py index 2390672..6d44bca 100644 --- a/bbp_ng/__init__.py +++ b/bbp_ng/__init__.py @@ -25,7 +25,7 @@ if "bpy" in locals(): from . import PROP_preferences, PROP_virtools_material from . import OP_IMPORT_bmfile, OP_EXPORT_bmfile, OP_IMPORT_virtools, OP_EXPORT_virtools -from . import OP_UV_flatten_uv +from . import OP_UV_flatten_uv, OP_UV_rail_uv #region Menu @@ -38,8 +38,8 @@ class BBP_MT_View3DMenu(bpy.types.Menu): def draw(self, context): layout = self.layout - layout.operator(OP_UV_flatten_uv.BBP_OT_flatten_uv.bl_idname) + layout.operator(OP_UV_rail_uv.BBP_OT_rail_uv.bl_idname) # ===== Menu Drawer ===== @@ -92,6 +92,7 @@ def register() -> None: OP_IMPORT_virtools.register() OP_EXPORT_virtools.register() + OP_UV_rail_uv.register() OP_UV_flatten_uv.register() # register other classes @@ -116,6 +117,7 @@ def unregister() -> None: # unregister modules OP_UV_flatten_uv.unregister() + OP_UV_rail_uv.unregister() OP_EXPORT_virtools.unregister() OP_IMPORT_virtools.unregister()