[Bf-extensions-cvs] [4d079c92] master: object_fracture_cell/crackit: moved to contrib: T63750 T61901
meta-androcto
noreply at git.blender.org
Fri May 24 08:12:19 CEST 2019
Commit: 4d079c92971494868612734e5e5d68fdf96e14c3
Author: meta-androcto
Date: Fri May 24 16:11:50 2019 +1000
Branches: master
https://developer.blender.org/rBAC4d079c92971494868612734e5e5d68fdf96e14c3
object_fracture_cell/crackit: moved to contrib: T63750 T61901
===================================================================
A object_fracture_cell/__init__.py
A object_fracture_cell/fracture_cell_calc.py
A object_fracture_cell/fracture_cell_setup.py
A object_fracture_crack/__init__.py
A object_fracture_crack/crack_it.py
A object_fracture_crack/materials/materials1.blend
A object_fracture_crack/operator.py
===================================================================
diff --git a/object_fracture_cell/__init__.py b/object_fracture_cell/__init__.py
new file mode 100644
index 00000000..e1fcb41f
--- /dev/null
+++ b/object_fracture_cell/__init__.py
@@ -0,0 +1,568 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+bl_info = {
+ "name": "Cell Fracture",
+ "author": "ideasman42, phymec, Sergey Sharybin",
+ "version": (0, 1),
+ "blender": (2, 70, 0),
+ "location": "Edit panel of Tools tab, in Object mode, 3D View tools",
+ "description": "Fractured Object, Bomb, Projectile, Recorder",
+ "warning": "",
+ "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
+ "Scripts/Object/CellFracture",
+ "category": "Object"}
+
+
+#if "bpy" in locals():
+# import importlib
+# importlib.reload(fracture_cell_setup)
+
+import bpy
+from bpy.props import (
+ StringProperty,
+ BoolProperty,
+ IntProperty,
+ FloatProperty,
+ FloatVectorProperty,
+ EnumProperty,
+ )
+
+from bpy.types import Operator
+
+def main_object(context, obj, level, **kw):
+ import random
+
+ # pull out some args
+ kw_copy = kw.copy()
+ use_recenter = kw_copy.pop("use_recenter")
+ use_remove_original = kw_copy.pop("use_remove_original")
+ recursion = kw_copy.pop("recursion")
+ recursion_source_limit = kw_copy.pop("recursion_source_limit")
+ recursion_clamp = kw_copy.pop("recursion_clamp")
+ recursion_chance = kw_copy.pop("recursion_chance")
+ recursion_chance_select = kw_copy.pop("recursion_chance_select")
+ use_layer_next = kw_copy.pop("use_layer_next")
+ use_layer_index = kw_copy.pop("use_layer_index")
+ group_name = kw_copy.pop("group_name")
+ use_island_split = kw_copy.pop("use_island_split")
+ use_debug_bool = kw_copy.pop("use_debug_bool")
+ use_interior_vgroup = kw_copy.pop("use_interior_vgroup")
+ use_sharp_edges = kw_copy.pop("use_sharp_edges")
+ use_sharp_edges_apply = kw_copy.pop("use_sharp_edges_apply")
+
+ collection = context.collection
+
+ if level != 0:
+ kw_copy["source_limit"] = recursion_source_limit
+
+ from . import fracture_cell_setup
+
+ # not essential but selection is visual distraction.
+ obj.select_set(False)
+
+ if kw_copy["use_debug_redraw"]:
+ obj_display_type_prev = obj.display_type
+ obj.display_type = 'WIRE'
+
+ objects = fracture_cell_setup.cell_fracture_objects(context, obj, **kw_copy)
+ objects = fracture_cell_setup.cell_fracture_boolean(context, obj, objects,
+ use_island_split=use_island_split,
+ use_interior_hide=(use_interior_vgroup or use_sharp_edges),
+ use_debug_bool=use_debug_bool,
+ use_debug_redraw=kw_copy["use_debug_redraw"],
+ level=level,
+ )
+
+ # must apply after boolean.
+ if use_recenter:
+ bpy.ops.object.origin_set({"selected_editable_objects": objects},
+ type='ORIGIN_GEOMETRY', center='MEDIAN')
+
+ if level == 0:
+ for level_sub in range(1, recursion + 1):
+
+ objects_recurse_input = [(i, o) for i, o in enumerate(objects)]
+
+ if recursion_chance != 1.0:
+ from mathutils import Vector
+ if recursion_chance_select == 'RANDOM':
+ random.shuffle(objects_recurse_input)
+ elif recursion_chance_select in {'SIZE_MIN', 'SIZE_MAX'}:
+ objects_recurse_input.sort(key=lambda ob_pair:
+ (Vector(ob_pair[1].bound_box[0]) -
+ Vector(ob_pair[1].bound_box[6])).length_squared)
+ if recursion_chance_select == 'SIZE_MAX':
+ objects_recurse_input.reverse()
+ elif recursion_chance_select in {'CURSOR_MIN', 'CURSOR_MAX'}:
+ c = scene.cursor.location.copy()
+ objects_recurse_input.sort(key=lambda ob_pair:
+ (ob_pair[1].location - c).length_squared)
+ if recursion_chance_select == 'CURSOR_MAX':
+ objects_recurse_input.reverse()
+
+ objects_recurse_input[int(recursion_chance * len(objects_recurse_input)):] = []
+ objects_recurse_input.sort()
+
+ # reverse index values so we can remove from original list.
+ objects_recurse_input.reverse()
+
+ objects_recursive = []
+ for i, obj_cell in objects_recurse_input:
+ assert(objects[i] is obj_cell)
+ objects_recursive += main_object(context, obj_cell, level_sub, **kw)
+ if use_remove_original:
+ collection.objects.unlink(obj_cell)
+ del objects[i]
+ if recursion_clamp and len(objects) + len(objects_recursive) >= recursion_clamp:
+ break
+ objects.extend(objects_recursive)
+
+ if recursion_clamp and len(objects) > recursion_clamp:
+ break
+
+ #--------------
+ # Level Options
+ if level == 0:
+ # import pdb; pdb.set_trace()
+ if use_interior_vgroup or use_sharp_edges:
+ fracture_cell_setup.cell_fracture_interior_handle(objects,
+ use_interior_vgroup=use_interior_vgroup,
+ use_sharp_edges=use_sharp_edges,
+ use_sharp_edges_apply=use_sharp_edges_apply,
+ )
+
+ #--------------
+ # Scene Options
+
+ # layer
+ layers_new = None
+ if use_layer_index != 0:
+ layers_new = [False] * 20
+ layers_new[use_layer_index - 1] = True
+ elif use_layer_next:
+ layers_new = [False] * 20
+ layers_new[(obj.layers[:].index(True) + 1) % 20] = True
+
+ if layers_new is not None:
+ for obj_cell in objects:
+ obj_cell.layers = layers_new
+
+ # group
+ if group_name:
+ group = bpy.data.collections.get(group_name)
+ if group is None:
+ group = bpy.data.collections.new(group_name)
+ group_objects = group.objects[:]
+ for obj_cell in objects:
+ if obj_cell not in group_objects:
+ group.objects.link(obj_cell)
+
+ if kw_copy["use_debug_redraw"]:
+ obj.display_type = obj_display_type_prev
+
+ # testing only!
+ # obj.hide = True
+ return objects
+
+
+def main(context, **kw):
+ import time
+ t = time.time()
+ objects_context = context.selected_editable_objects
+
+ kw_copy = kw.copy()
+
+ # mass
+ mass_mode = kw_copy.pop("mass_mode")
+ mass = kw_copy.pop("mass")
+
+ objects = []
+ for obj in objects_context:
+ if obj.type == 'MESH':
+ objects += main_object(context, obj, 0, **kw_copy)
+
+ bpy.ops.object.select_all(action='DESELECT')
+ for obj_cell in objects:
+ obj_cell.select_set(True)
+
+ if mass_mode == 'UNIFORM':
+ for obj_cell in objects:
+ obj_cell.game.mass = mass
+ elif mass_mode == 'VOLUME':
+ from mathutils import Vector
+ def _get_volume(obj_cell):
+ def _getObjectBBMinMax():
+ min_co = Vector((1000000.0, 1000000.0, 1000000.0))
+ max_co = -min_co
+ matrix = obj_cell.matrix_world
+ for i in range(0, 8):
+ bb_vec = obj_cell.matrix_world * Vector(obj_cell.bound_box[i])
+ min_co[0] = min(bb_vec[0], min_co[0])
+ min_co[1] = min(bb_vec[1], min_co[1])
+ min_co[2] = min(bb_vec[2], min_co[2])
+ max_co[0] = max(bb_vec[0], max_co[0])
+ max_co[1] = max(bb_vec[1], max_co[1])
+ max_co[2] = max(bb_vec[2], max_co[2])
+ return (min_co, max_co)
+
+ def _getObjectVolume():
+ min_co, max_co = _getObjectBBMinMax()
+ x = max_co[0] - min_co[0]
+ y = max_co[1] - min_co[1]
+ z = max_co[2] - min_co[2]
+ volume = x * y * z
+ return volume
+
+ return _getObjectVolume()
+
+
+ obj_volume_ls = [_get_volume(obj_cell) for obj_cell in objects]
+ obj_volume_tot = sum(obj_volume_ls)
+ if obj_volume_tot > 0.0:
+ mass_fac = mass / obj_volume_tot
+ for i, obj_cell in enumerate(objects):
+ obj_cell.game.mass = obj_volume_ls[i] * mass_fac
+ else:
+ assert(0)
+
+ print("Done! %d objects in %.4f sec" % (len(objects), time.time() - t))
+
+
+class FractureCell(Operator):
+ bl_idname = "object.add_fracture_cell_objects"
+ bl_label = "Cell fracture selected mesh objects"
+ bl_options = {'PRESET'}
+
+ # -------------------------------------------------------------------------
+ # Source Options
+ source: EnumProperty(
+ name="Source",
+ items=(('VERT_OWN', "Own Verts", "Use own vertices"),
+ ('VERT_CHILD', "Child Verts", "Use child obj
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-extensions-cvs
mailing list