def correct_bone_positions(bones): for dest_name, end, root_name, root_end, axis in bones_to_correct_spine_position: root_bone = bones.get(root_name) root = Vector(getattr(root_bone, root_end)) dest = bones.get(dest_name) dest_head = Vector(dest.head) dest_tail = Vector(dest.tail) if end == "head": setattr(dest_head, axis, getattr(root, axis)) dest.head = dest_head elif end == "tail": print("set tail") setattr(dest_tail, axis, getattr(root, axis)) dest.tail = dest_tail # now do toes leftToe = bones.get("LeftToeBase") leftToeHead = Vector(leftToe.head) leftToeTail = Vector(leftToe.tail) leftToeTail.x = leftToeHead.x leftToeTail.z = leftToeHead.z leftToe.tail = leftToeTail rightToe = bones.get("RightToeBase") rightToeHead = Vector(rightToe.head) rightToeTail = Vector(rightToe.tail) rightToeTail.x = rightToeHead.x rightToeTail.z = rightToeHead.z rightToe.tail = rightToeTail
def getBoundingBox(scene): minimum = Vector() maximum = Vector() for obj in scene.objects: if obj.type == 'MESH': bbox_corners = [obj.matrix_world * Vector(corner) for corner in obj.bound_box] for v in bbox_corners: if v.x < minimum.x: minimum.x = v.x if v.y < minimum.y: minimum.y = v.y if v.z < minimum.z: minimum.z = v.z if v.x > maximum.x: maximum.x = v.x if v.y > maximum.y: maximum.y = v.y if v.z > maximum.z: maximum.z = v.z return { "minimum" : { "x" : minimum.x, "y" : minimum.y, "z" : minimum.z }, "maximum" : { "x" : maximum.x, "y" : maximum.y, "z" : maximum.z } }
def combine_bounds(bounds: Iterable[BoundsDataStruct_YK1]) -> BoundsDataStruct_YK1: # min_pos = None # max_pos = None min_pos = Vector((-1000, -1000, -1000)) max_pos = Vector((+1000, +1000, +1000)) for bound in bounds: min_for_bound = bound.center - bound.box_extents max_for_bound = bound.center - bound.box_extents if min_pos is None: min_pos = min_for_bound max_pos = max_for_bound else: min_pos.x = min(min_for_bound.x, min_pos.x) min_pos.y = min(min_for_bound.y, min_pos.y) min_pos.z = min(min_for_bound.z, min_pos.z) max_pos.x = max(max_for_bound.x, max_pos.x) max_pos.y = max(max_for_bound.y, max_pos.y) max_pos.z = max(max_for_bound.z, max_pos.z) # TODO - This is for the sake of hierarchy objects which have no meshes themselves, but presumably have children with meshes. # Will these BBOXes need to be calculated with those other ones in mind? # Will these BBOXes need to be calculated with object position in mind? # if min_pos is None: # min_pos = Vector((0, 0, 0, 0)) # max_pos = Vector((0, 0, 0, 0)) return bounds_from_minmax(min_pos, max_pos)
def calcAlign(self, localArea): alnVec = Vector([0, 0, 0]) if len(localArea) == 0: return alnVec agents = self.sim.agents for neighbour in localArea: alnVec.x += agents[neighbour].arx alnVec.y += agents[neighbour].ary alnVec.z += agents[neighbour].arz alnVec /= len(localArea) alnVec.x -= agents[self.userid].arx alnVec.y -= agents[self.userid].ary alnVec.z -= agents[self.userid].arz alnVec.x %= 2 * math.pi alnVec.y %= 2 * math.pi alnVec.z %= 2 * math.pi if alnVec.x < math.pi: alnVec.x = alnVec.x / math.pi else: alnVec.x = -2 + alnVec.x / math.pi if alnVec.y < math.pi: alnVec.y = alnVec.y / math.pi else: alnVec.y = -2 + alnVec.y / math.pi if alnVec.z < math.pi: alnVec.z = alnVec.z / math.pi else: alnVec.z = -2 + alnVec.z / math.pi return alnVec
def calcAlign(self, localArea): alnVec = Vector([0, 0, 0]) if len(localArea) == 0: return alnVec agents = self.sim.agents for neighbour in localArea: alnVec.x += agents[neighbour].arx alnVec.y += agents[neighbour].ary alnVec.z += agents[neighbour].arz alnVec /= len(localArea) alnVec.x -= agents[self.userid].arx alnVec.y -= agents[self.userid].ary alnVec.z -= agents[self.userid].arz alnVec.x %= 2*math.pi alnVec.y %= 2*math.pi alnVec.z %= 2*math.pi if alnVec.x < math.pi: alnVec.x = alnVec.x/math.pi else: alnVec.x = -2 + alnVec.x/math.pi if alnVec.y < math.pi: alnVec.y = alnVec.y/math.pi else: alnVec.y = -2 + alnVec.y/math.pi if alnVec.z < math.pi: alnVec.z = alnVec.z/math.pi else: alnVec.z = -2 + alnVec.z/math.pi return alnVec
def getBoundsBF(obj): """ brute force method for obtaining object bounding box """ # initialize min and max min = Vector((math.inf, math.inf, math.inf)) max = Vector((-math.inf, -math.inf, -math.inf)) # calculate min and max verts for v in obj.data.vertices: if v.co.x > max.x: max.x = v.co.x elif v.co.x < min.x: min.x = v.co.x if v.co.y > max.y: max.y = v.co.y elif v.co.y < min.y: min.y = v.co.y if v.co.z > max.z: max.z = v.co.z elif v.co.z < min.z: min.z = v.co.z # set up bounding box list of coord lists bound_box = [list(min), [min.x, min.y, min.z], [min.x, min.y, max.z], [min.x, max.y, max.z], [min.x, max.y, min.z], [max.x, min.y, min.z], [max.y, min.y, max.z], list(max), [max.x, max.y, min.z]] return bound_box
def readPackedVector(f, format): packed = f output = Vector() if format == 'XZY': output.x = packed output.y = packed / 65536.0 output.z = packed / 256.0 elif format == 'ZXY': output.x = packed / 256.0 output.y = packed / 65536.0 output.z = packed elif format == 'XYZ': output.x = packed output.y = packed / 256.0 output.z = packed / 65536.0 output.x -= math.floor(output.x) output.y -= math.floor(output.y) output.z -= math.floor(output.z) output.x = output.x*2 - 1 output.y = output.y*2 - 1 output.z = output.z*2 - 1 return output
def getBoundsBF(obj:Object): """ brute force method for obtaining object bounding box """ # initialize min and max min = Vector((math.inf, math.inf, math.inf)) max = Vector((-math.inf, -math.inf, -math.inf)) # calculate min and max verts for v in obj.data.vertices: if v.co.x > max.x: max.x = v.co.x elif v.co.x < min.x: min.x = v.co.x if v.co.y > max.y: max.y = v.co.y elif v.co.y < min.y: min.y = v.co.y if v.co.z > max.z: max.z = v.co.z elif v.co.z < min.z: min.z = v.co.z # set up bounding box list of coord lists bound_box = [list(min), [min.x, min.y, min.z], [min.x, min.y, max.z], [min.x, max.y, max.z], [min.x, max.y, min.z], [max.x, min.y, min.z], [max.y, min.y, max.z], list(max), [max.x, max.y, min.z]] return bound_box
def analyzeMeshObject(obj, meshFaces): global DEFAULT_PART_NAME mesh = obj.data parts = [] halfSize = obj.dimensions * 0.5 candidParts = [] centerOfMass = Vector((0.0, 0.0, 0.0)) trianglesCount = 0 meshVerticesCount = len(mesh.vertices) meshMaterialCount = len(mesh.materials) if meshMaterialCount > 0: # Create parts. It is important to iterate it manually # so material names order is preserved. for i in range(meshMaterialCount): candidParts.append({'name': mesh.materials[i].name, 'start': 0, 'count': 0}) else: # If there are no materials defined, create default part placeholder. candidParts.append({'name': DEFAULT_PART_NAME, 'start': 0, 'count': 0}) for f in meshFaces: # Some faces can be quads - values have to doubled then. modifier = 2 if len(f.vertices) == 4 else 1 candidParts[f.material_index]['count'] += 3 * modifier trianglesCount += 1 * modifier # Update part`s start attribute so they take other parts into account. for i in range(0, len(candidParts)): if i > 0: candidParts[i]['start'] = candidParts[i - 1]['start'] + candidParts[i - 1]['count'] # Only export parts that have any triangles assigned. for p in candidParts: if p['count'] > 0: parts.append(p) centerMax = Vector((-9999.999, -9999.999, -9999.999)) centerMin = Vector(( 9999.999, 9999.999, 9999.999)) for v in mesh.vertices: centerMax.x = max(centerMax.x, v.co.x) centerMin.x = min(centerMin.x, v.co.x) centerMax.y = max(centerMax.y, v.co.y) centerMin.y = min(centerMin.y, v.co.y) centerMax.z = max(centerMax.z, v.co.z) centerMin.z = min(centerMin.z, v.co.z) centerOfMass.x = abs(centerMax.x) - abs(centerMin.x) centerOfMass.y = abs(centerMax.y) - abs(centerMin.y) centerOfMass.z = abs(centerMax.z) - abs(centerMin.z) centerOfMass *= 0.5 return centerOfMass, halfSize, trianglesCount, parts
def calcBBPos(x, y, z, a1, a2, a3, type='DNA'): bb = Vector() if type is 'DNA': bb.x = x - (0.34 * a1.x + 0.3408 * a2.x) bb.y = y - (0.34 * a1.y + 0.3408 * a2.y) bb.z = z - (0.34 * a1.z + 0.3408 * a2.z) elif type is 'RNA': bb.x = x - (0.4 * a1.x + 0.2 * a3.x) bb.y = y - (0.4 * a1.y + 0.2 * a3.y) bb.z = z - (0.4 * a1.z + 0.2 * a3.z) return bb
def bounding_box(mesh): v0 = mesh.vertices[0].co vmin = Vector((v0.x, v0.y, v0.z)) vmax = Vector((v0.x, v0.y, v0.z)) for i in range(1, len(mesh.vertices)): v = mesh.vertices[i].co vmin.x = min(vmin.x, v.x) vmin.y = min(vmin.y, v.y) vmin.z = min(vmin.z, v.z) vmax.x = max(vmax.x, v.x) vmax.y = max(vmax.y, v.y) vmax.z = max(vmax.z, v.z) return vmin, vmax
def bounding_box(mesh): v0 = mesh.vertices[0].co vmin = Vector((v0.x, v0.y, v0.z)) vmax = Vector((v0.x, v0.y, v0.z)) for i in range(1, len(mesh.vertices)): v = mesh.vertices[i].co vmin.x = min(vmin.x, v.x) vmin.y = min(vmin.y, v.y) vmin.z = min(vmin.z, v.z) vmax.x = max(vmax.x, v.x) vmax.y = max(vmax.y, v.y) vmax.z = max(vmax.z, v.z) return vmin, vmax
def execute(self, context): switchMode = False if context.mode != 'OBJECT': switchMode = True bpy.ops.object.mode_set(mode='OBJECT', toggle=True) for o in context.selected_objects: if o.type == "MESH": d = o.data m = o.matrix_world if self.center: bounds_center = (sum( (m @ Vector(b) for b in o.bound_box), Vector())) / 8 difference = m.translation - bounds_center local_difference = difference @ m for v in d.vertices: v.co += local_difference m.translation -= difference difference = Vector((0, 0, 0)) if self.side == 'X': bound = max((m @ v.co).x for v in d.vertices) difference.x = m.translation.x - bound elif self.side == '-X': bound = min((m @ v.co).x for v in d.vertices) difference.x = m.translation.x - bound elif self.side == 'Y': bound = max((m @ v.co).y for v in d.vertices) difference.y = m.translation.y - bound elif self.side == '-Y': bound = min((m @ v.co).y for v in d.vertices) difference.y = m.translation.y - bound elif self.side == 'Z': bound = max((m @ v.co).z for v in d.vertices) difference.z = m.translation.z - bound elif self.side == '-Z': bound = min((m @ v.co).z for v in d.vertices) difference.z = m.translation.z - bound local_difference = difference @ m for v in d.vertices: v.co += local_difference m.translation -= difference if self.move: o.location = context.scene.cursor.location if switchMode: bpy.ops.object.mode_set(mode='OBJECT', toggle=True) return {'FINISHED'}
def calc_box(self): if not self.verts: return Vector((0, 0, 0)), Vector((0, 0, 0)) mins = Vector(self.verts[0]) maxs = Vector(self.verts[0]) for v in self.verts: mins.x = min(mins.x, v.x) mins.y = min(mins.y, v.y) mins.z = min(mins.z, v.z) maxs.x = max(maxs.x, v.x) maxs.y = max(maxs.y, v.y) maxs.z = max(maxs.z, v.z) size = (maxs - mins) center = (maxs + mins) / 2 return size, center
def find_HalfExtent_scale(loc): scale = Vector() values = loc.find("*[@Name='HalfExtents']").attrib scale.x = float(values['X']) scale.y = float(values['Z']) scale.z = float(values['Y']) return scale
def modal(self, context, event): props = context.scene.tom_props prefs = context.user_preferences.addons[__name__].preferences # 3Dビューの画面を更新 if context.area: context.area.tag_redraw() # キーボードのQキーが押された場合は、オブジェクト並進移動モードを終了 if event.type == 'Q' and event.value == 'PRESS': props.running = False print("サンプル3-10: 通常モードへ移行しました。") return {'FINISHED'} if event.value == 'PRESS': value = Vector((0.0, 0.0, 0.0)) if event.type == prefs.x_axis: value.x = 1.0 if not event.shift else -1.0 if event.type == prefs.y_axis: value.y = 1.0 if not event.shift else -1.0 if event.type == prefs.z_axis: value.z = 1.0 if not event.shift else -1.0 # 選択中のオブジェクトを並進移動する bpy.ops.transform.translate(value=value) return {'RUNNING_MODAL'}
def sRGB2linear(rgb): a = 0.055 lrgb = Vector() lrgb.x = s2lin(rgb.x) lrgb.y = s2lin(rgb.y) lrgb.z = s2lin(rgb.z) return lrgb
def modal(self, context, event): props = context.scene.tom_props # @include-source start [get_prefs] prefs = context.user_preferences.addons[__name__].preferences # @include-source end [get_prefs] # 3Dビューの画面を更新 if context.area: context.area.tag_redraw() # キーボードのQキーが押された場合は、オブジェクト並進移動モードを終了 if event.type == 'Q' and event.value == 'PRESS': props.running = False print("サンプル3-10: 通常モードへ移行しました。") return {'FINISHED'} # @include-source start [refer_prefs] if event.value == 'PRESS': value = Vector((0.0, 0.0, 0.0)) if event.type == prefs.x_axis: value.x = 1.0 if not event.shift else -1.0 if event.type == prefs.y_axis: value.y = 1.0 if not event.shift else -1.0 if event.type == prefs.z_axis: value.z = 1.0 if not event.shift else -1.0 # 選択中のオブジェクトを並進移動する bpy.ops.transform.translate(value=value) # @include-source end [refer_prefs] return {'RUNNING_MODAL'}
def update(self, ctx, clickcount, dimantion): dim = dimantion if self.shift: index = -1 if len(self.subclass.knots) < 2 else -2 lastpoint = self.subclass.knots[index].pos dim.view = get_axis_constraint(lastpoint, dim.view) if self.drag: pos = self.subclass.knots[-1].pos outvec = dim.view invec = Vector((0,0,0)) invec.x = pos.x - (outvec.x - pos.x) invec.y = pos.y - (outvec.y - pos.y) invec.z = pos.z - (outvec.z - pos.z) newknot = knot(pos, invec, outvec, 'ALIGNED') else: newknot = knot(dim.view, dim.view, dim.view, "VECTOR") if clickcount != self.lastclick: self.subclass.knots.append(newknot) self.lastclick = clickcount check_for_close(self, ctx) if LineData.close: self.subclass.knots.pop() self.subclass.close = True self.forcefinish = True self.subclass.knots[-1] = newknot self.subclass.lastknot = [knot(dim.view, dim.view, dim.view, "VECTOR")] self.subclass.update(ctx)
def render(self): diameter = 4.0 sz = 2.125 / diameter base_object = helpers.infer_primitive(random.choice(self.PRIMITIVES), location=(100, 100, 100), radius=sz) latitude = 16 longitude = latitude * 2 invlatitude = 1.0 / (latitude - 1) invlongitude = 1.0 / (longitude - 1) iprc = 0.0 jprc = 0.0 phi = 0.0 theta = 0.0 invfcount = 1.0 / (self.NUMBER_OF_FRAMES - 1) # Animate center of the sphere. center = Vector((0.0, 0.0, 0.0)) startcenter = Vector((0.0, -4.0, 0.0)) stopcenter = Vector((0.0, 4.0, 0.0)) # Rotate cubes around the surface of the sphere. pt = Vector((0.0, 0.0, 0.0)) rotpt = Vector((0.0, 0.0, 0.0)) # Change the axis of rotation for the point. baseaxis = Vector((0.0, 1.0, 0.0)) axis = Vector((0.0, 0.0, 0.0)) # Slerp between two rotations for each cube. startrot = Quaternion((0.0, 1.0, 0.0), pi) stoprot = Quaternion((1.0, 0.0, 0.0), pi * 1.5) currot = Quaternion() for i in range(0, latitude, 1): iprc = i * invlatitude phi = pi * (i + 1) * invlatitude rad = 0.01 + sz * abs(sin(phi)) * 0.99 pt.z = cos(phi) * diameter for j in range(0, longitude, 1): jprc = j * invlongitude theta = TWOPI * j / longitude pt.y = center.y + sin(phi) * sin(theta) * diameter pt.x = center.x + sin(phi) * cos(theta) * diameter current = helpers.duplicate_object(base_object) current.location = pt current.name = 'Object ({0:0>2d}, {1:0>2d})'.format(i, j) current.data.name = 'Mesh ({0:0>2d}, {1:0>2d})'.format(i, j) current.rotation_euler = (0.0, phi, theta) helpers.assign_material( current, helpers.random_material(self.MATERIALS_NAMES)) axis = self.vecrotatex(theta, baseaxis) currot = startrot center = startcenter for f in range(0, self.NUMBER_OF_FRAMES, 1): fprc = f / (self.NUMBER_OF_FRAMES - 1) osc = abs(sin(TWOPI * fprc)) bpy.context.scene.frame_set(f) center = startcenter.lerp(stopcenter, osc) current.location = helpers.rotate_vector( TWOPI * fprc, axis, pt) current.keyframe_insert(data_path='location') currot = startrot.slerp(stoprot, jprc * fprc) current.rotation_euler = currot.to_euler() current.keyframe_insert(data_path='rotation_euler')
def calculate_bbox(verts, matrix=None): mapped_verts = verts if matrix is not None: mapped_verts = map(lambda v, M=matrix: M @ v, verts) bbox_min = Vector(next(mapped_verts)) bbox_max = bbox_min.copy() for v in mapped_verts: if v.x < bbox_min.x: bbox_min.x = v.x if v.y < bbox_min.y: bbox_min.y = v.y if v.z < bbox_min.z: bbox_min.z = v.z if v.x > bbox_max.x: bbox_max.x = v.x if v.y > bbox_max.y: bbox_max.y = v.y if v.z > bbox_max.z: bbox_max.z = v.z # Return bounding box verts return bbox_min, bbox_max
def item_to_vector(item): """Converts XML item object to vector. SWAPS Y and Z""" v = Vector() v.x = float(item.attrib['X']) v.y = float(item.attrib['Z']) v.z = float(item.attrib['Y']) return v
def read_vector4(io_stream): vec = Vector((0, 0, 0, 0)) vec.x = read_float(io_stream) vec.y = read_float(io_stream) vec.z = read_float(io_stream) vec.w = read_float(io_stream) return vec
def getRandomLoc(randomLoc, rand, width, height): """ get random location between (0,0,0) and (width/2, width/2, height/2) """ loc = Vector((0, 0, 0)) loc.xy = [rand.uniform(-(width / 2) * randomLoc, (width / 2) * randomLoc)] * 2 loc.z = rand.uniform(-(height / 2) * randomLoc, (height / 2) * randomLoc) return loc
def modal(self, context, event): props = context.scene.tom_props # 3Dビューの画面を更新 if context.area: context.area.tag_redraw() # キーボードのQキーが押された場合は、オブジェクト並進移動モードを終了 if event.type == 'Q' and event.value == 'PRESS': props.running = False print("サンプル3-2: 通常モードへ移行しました。") return {'FINISHED'} if event.value == 'PRESS': value = Vector((0.0, 0.0, 0.0)) if event.type == 'X': value.x = 1.0 if not event.shift else -1.0 if event.type == 'Y': value.y = 1.0 if not event.shift else -1.0 if event.type == 'Z': value.z = 1.0 if not event.shift else -1.0 # 選択中のオブジェクトを並進移動する bpy.ops.transform.translate(value=value) return {'RUNNING_MODAL'}
def find_xyz(loc, valname): """returns vector named valname in loc""" v = Vector() values = loc.find(f"*[@Name='{valname}']").attrib v.x = float(values['X']) v.y = float(values['Z']) v.z = float(values['Y']) return v
def find_xyz_from_mat(loc, mat_name): """returns xyz from matrix named mat_name in loc""" a = Vector() values = loc.find(f"*[@Name='{mat_name}']").attrib a.x = float(values['M41']) a.y = float(values['M43']) a.z = float(values['M42']) return a
def fencehop(): cont = bge.logic.getCurrentController() own = cont.owner auto_action = cont.sensors['auto_action'] if not auto_action: return False elif own['isSpaceon']: #Gather info on the fence fence_obj = auto_action.hitObject fence_pos = fence_obj.worldPosition #get the normal of the fence hit_norm = Vector(auto_action.hitNormal) hit_norm.z = 0.0 #Vector axis of Sintel own_negative_y = Vector(own.getAxisVect((0.0, -1.0, 0.0))) own_negative_y.z = 0.0 #Cross it, then get the absolute vaule cross = hit_norm.cross(own_negative_y) cross = math.fabs(cross[2]) #print (cross) #Check the angle of approach if cross <=.5: new_pos = (fence_pos[2] + 2) own.worldPosition[2] = new_pos own['Leaping']=True CURRENT_SPEED = own.getLinearVelocity(True) if CURRENT_SPEED[1] < 11: CURRENT_SPEED[1] = 11 CURRENT_SPEED[2] = 10 #print (CURRENT_SPEED) own.setLinearVelocity(CURRENT_SPEED ,True) own['Tracking']=False return True else: return False
def get_min_max(vertList): min = Vector(vertList[0]) max = Vector(vertList[0]) for v in vertList: if v.x < min.x: min.x = v.x elif v.x > max.x: max.x = v.x if v.y < min.y: min.y = v.y elif v.y > max.y: max.y = v.y if v.z < min.z: min.z = v.z elif v.z > max.z: max.z = v.z return min, max
def fencehop(): cont = bge.logic.getCurrentController() own = cont.owner auto_action = cont.sensors['auto_action'] if not auto_action: return False elif own['isSpaceon']: #Gather info on the fence fence_obj = auto_action.hitObject fence_pos = fence_obj.worldPosition #get the normal of the fence hit_norm = Vector(auto_action.hitNormal) hit_norm.z = 0.0 #Vector axis of Sintel own_negative_y = Vector(own.getAxisVect((0.0, -1.0, 0.0))) own_negative_y.z = 0.0 #Cross it, then get the absolute vaule cross = hit_norm.cross(own_negative_y) cross = math.fabs(cross[2]) #print (cross) #Check the angle of approach if cross <= .5: new_pos = (fence_pos[2] + 2) own.worldPosition[2] = new_pos own['Leaping'] = True CURRENT_SPEED = own.getLinearVelocity(True) if CURRENT_SPEED[1] < 11: CURRENT_SPEED[1] = 11 CURRENT_SPEED[2] = 10 #print (CURRENT_SPEED) own.setLinearVelocity(CURRENT_SPEED, True) own['Tracking'] = False return True else: return False
def onKeyPressed(self, keys): rot = self.obj.worldOrientation.to_euler() pos = Vector([0, 0, 0]) if key.W in keys: rot.x += 0.01 if key.S in keys: rot.x -= 0.01 if key.A in keys: rot.z += 0.01 if key.D in keys: rot.z -= 0.01 if key.WHEELUPMOUSE in keys: pos.z = -self.obj.worldPosition.z * 0.3 if key.WHEELDOWNMOUSE in keys: pos.z = self.obj.worldPosition.z * 0.3 #Max speed is dependent of the Tile sizes, ex (200m/s = size) / 50fps = 4m/tick #Since we are using an extra radius we can guarante a speed of 8m/tick without glitches: 8*60fps = 480m/s = 1728 km/h #if pos.length > 8: pos.length = 8 #But we don't care for now if pos.length > 50: pos.length = 50 pos.rotate(self.obj.worldOrientation) self.obj.worldPosition += pos self.obj.worldOrientation = rot
def onKeyPressed(self, keys): rot = self.obj.worldOrientation.to_euler() pos = Vector([0,0,0]) if key.W in keys: rot.x += 0.01 if key.S in keys: rot.x -= 0.01 if key.A in keys: rot.z += 0.01 if key.D in keys: rot.z -= 0.01 if key.WHEELUPMOUSE in keys: pos.z = -self.obj.worldPosition.z * 0.3 if key.WHEELDOWNMOUSE in keys: pos.z = self.obj.worldPosition.z * 0.3 #Max speed is dependent of the Tile sizes, ex (200m/s = size) / 50fps = 4m/tick #Since we are using an extra radius we can guarante a speed of 8m/tick without glitches: 8*60fps = 480m/s = 1728 km/h #if pos.length > 8: pos.length = 8 #But we don't care for now if pos.length > 50: pos.length = 50 pos.rotate(self.obj.worldOrientation) self.obj.worldPosition += pos self.obj.worldOrientation = rot
def get_max(ob): mx = Vector((-1000., -1000., -1000.)) for vx in ob.data.vertices: p = ob.matrix_world * vx.co mx.x = max(mx.x, p.x) mx.y = max(mx.y, p.y) mx.z = max(mx.z, p.z) return mx
def processCamera(cont): own = cont.owner axis = own.childrenRecursive["CameraAxis"] own.scene.active_camera.timeOffset = CAMERA_SMOOTH posVector = Vector((0, 0, 0)) if own["Landing"]: posVector.y = VIEW_HEIGHT_DISTANCE * 3 posVector.z = VIEW_HEIGHT_DISTANCE else: posVector.z = -VIEW_HEIGHT_DISTANCE if own["DirectionH"] == "Left": posVector.x = -VIEW_AHEAD_DISTANCE elif own["DirectionH"] == "Right": posVector.x = VIEW_AHEAD_DISTANCE axis.worldPosition = own.worldPosition + posVector
def get_all_max_min(): min_p = Vector([float('inf'), float('inf'), float('inf')]) max_p = Vector([-float('inf'), -float('inf'), -float('inf')]) for obj in bpy.data.objects: if obj.type != 'MESH': continue max_min = get_object_max_min(obj) # Max max_p.x = max(max_p.x, max_min['max'].x) max_p.y = max(max_p.y, max_min['max'].y) max_p.z = max(max_p.z, max_min['max'].z) # Min min_p.x = min(min_p.x, max_min['min'].x) min_p.y = min(min_p.y, max_min['min'].y) min_p.z = min(min_p.z, max_min['min'].z) return { 'min': min_p, 'max': max_p }
def get_random_loc(random_loc, rand, half_width, half_height): """ get random location between (0,0,0) and (width/2, width/2, height/2) """ loc = Vector((0, 0, 0)) if random_loc > 0: loc.xy = [ rand.uniform(-half_width * random_loc, half_width * random_loc) ] * 2 loc.z = rand.uniform(-half_height * random_loc, half_height * random_loc) return loc
def __neg__(self): """ return antipodal point """ coo=Vector() if self.co.x > 0: coo.x = self.co.x - math.pi else: coo.x = self.co.x + math.pi coo.y = abs(math.pi - self.co.y) coo.z = -self.co.z return Reflection(co=coo, normalize=False)
def roi2point(self, msg): """ Returns a normalized point at the center of the given RegionOfInterest message. """ p = Vector([0,0,0]) if self.camerainfo.width > 0: p.x = 0.5 - (msg.x_offset+(msg.width/2.0))/self.camerainfo.width if self.camerainfo.height > 0: p.z = 0.5 - (msg.y_offset+(msg.height/2.0))/self.camerainfo.height return p
def read_vector_axis_vecteur(node): v = Vector((0.0, 0.0, 0.0)) childs = node.getElementsByTagName('x') if childs: v.x = ret_float_value(childs[0]) childs = node.getElementsByTagName('y') if childs: v.y = ret_float_value(childs[0]) childs = node.getElementsByTagName('z') if childs: v.z = ret_float_value(childs[0]) return v
def execute(self, context): scene = context.scene obj = context.active_object # check if active object is a mesh object if not obj or obj.type != 'MESH': self.report({'ERROR'}, "No selected mesh object!") return {'CANCELLED'} # check if it has one single face if len(obj.data.polygons) != 1: self.report( {'ERROR'}, "The selected mesh object has to have exactly one quad!") return {'CANCELLED'} rl = scene.lightfield.row_length # use a degree angle here angle = degrees(scene.lightfield.angle) spacing = scene.lightfield.spacing # resolution of final renderings res = round(scene.render.resolution_x * (scene.render.resolution_percentage / 100.)) width = self.getWidth(obj) # the offset between n pixels on the focal plane fplane_offset = (width / res) * spacing # vertices for the basemesh verts = [] # the offset vector vec = self.getCamVec(obj, angle) # lower left coordinates of the grid sx = obj.location[0] - fplane_offset * int(rl / 2) sy = obj.location[1] - fplane_offset * int(rl / 2) z = obj.location[2] # position on the focal plane fplane_pos = Vector() for x in [sx + fplane_offset * i for i in range(rl)]: for y in [sy + fplane_offset * i for i in range(rl)]: fplane_pos.x = x fplane_pos.y = y fplane_pos.z = z # position of a vertex in a basemesh pos = fplane_pos + vec # pack coordinates flat into the vert list verts.append((pos.x, pos.y, pos.z)) # setup the basemesh and add verts mesh = bpy.data.meshes.new(self.objName) mesh.from_pydata(verts, [], []) self.addMeshObj(mesh) return {'FINISHED'}
def main(): cont = bge.logic.getCurrentController() own = cont.owner wall_ray = cont.sensors["wall_ray"] wall_normal = Vector(wall_ray.hitNormal) wall_normal.z = 0.0 own_negative_y = Vector(own.getAxisVect((0.0, -1.0, 0.0))) own_negative_y.z = 0.0 cross = wall_normal.cross(own_negative_y) if cross.z > 0.0: new_dir = Matrix.Rotation(-90.0, 3, 'X') * wall_normal else: new_dir = Matrix.Rotation(90.0, 3, 'X') * wall_normal #print (new_dir) #own.alignAxisToVect(new_dir, 0, .1)
def _move(self, direction, value): """ Moves view into direction by value. """ for view in self.get3DView(): offset = Vector((0.0, 0.0, 0.0)) if direction == "horizontal": offset.x = value elif direction == "vertical": offset.y = value elif direction == "straightforward": offset.z = value view.view_location = view.view_rotation*offset + view.view_location
def getDimensions(self): highest = Vector((-10000, -10000, -10000)) lowest = Vector(( 10000, 10000, 10000)) for bone in self.bones: if highest.x < bone.restHead.x: highest.x = bone.restHead.x if highest.y < bone.restHead.y: highest.y = bone.restHead.y if highest.z < bone.restHead.z: highest.z = bone.restHead.z if highest.x < bone.restTail.x: highest.x = bone.restTail.x if highest.y < bone.restTail.y: highest.y = bone.restTail.y if highest.z < bone.restTail.z: highest.z = bone.restTail.z if lowest .x > bone.restHead.x: lowest .x = bone.restHead.x if lowest .y > bone.restHead.y: lowest .y = bone.restHead.y if lowest .z > bone.restHead.z: lowest .z = bone.restHead.z if lowest .x > bone.restTail.x: lowest .x = bone.restTail.x if lowest .y > bone.restTail.y: lowest .y = bone.restTail.y if lowest .z > bone.restTail.z: lowest .z = bone.restTail.z return Vector((highest.x - lowest.x, highest.y - lowest.y, highest.z - lowest.z))
def execute(self, context): scene = context.scene obj = context.active_object # check if active object is a mesh object if not obj or obj.type != 'MESH': self.report({'ERROR'}, "No selected mesh object!") return {'CANCELLED'} # check if it has one single face if len(obj.data.polygons) != 1: self.report({'ERROR'}, "The selected mesh object has to have exactly one quad!") return {'CANCELLED'} rl = scene.lightfield.row_length # use a degree angle here angle = degrees(scene.lightfield.angle) spacing = scene.lightfield.spacing # resolution of final renderings res = round(scene.render.resolution_x * (scene.render.resolution_percentage / 100.)) width = self.getWidth(obj) # the offset between n pixels on the focal plane fplane_offset = (width / res) * spacing # vertices for the basemesh verts = [] # the offset vector vec = self.getCamVec(obj, angle) # lower left coordinates of the grid sx = obj.location[0] - fplane_offset * int(rl / 2) sy = obj.location[1] - fplane_offset * int(rl / 2) z = obj.location[2] # position on the focal plane fplane_pos = Vector() for x in [sx + fplane_offset * i for i in range(rl)]: for y in [sy + fplane_offset * i for i in range(rl)]: fplane_pos.x = x fplane_pos.y = y fplane_pos.z = z # position of a vertex in a basemesh pos = fplane_pos + vec # pack coordinates flat into the vert list verts.append((pos.x, pos.y, pos.z)) # setup the basemesh and add verts mesh = bpy.data.meshes.new(self.objName) mesh.from_pydata(verts, [], []) self.addMeshObj(mesh) return {'FINISHED'}
def Translate(mesh, vtx_weight_dict, shapekey_out, dx, dy, dz): # Purpose: translate vertices in the weight dict somewhere verts = shapekey_out.data vwd = vtx_weight_dict d = Vector((0,0,0)) for i in range(len(verts)): if i in vwd: d.x = dx d.y = dy d.z = dz verts[i].co += vwd[i] * d else: continue
def calcBranch(self, branch, angle=0): rotation = uniform(0, pi * 2) br = copy(branch) a = br.a o = Vector([uniform(-1,1),uniform(-1,1),uniform(-1,1)]) if a.x != 0: o.x = -(a.y * o.y + a.z * o.z) / a.x elif a.y != 0: o.y = -(a.x * o.x + a.z * o.z) / a.y elif a.z != 0: o.z = -(a.x * o.x + a.y * o.y) / a.z else: raise Exception("Invalid input: zero vector") o = norm(o) assert(inner_product(o) > .9999 or inner_product(o) < 1.0001) assert(o * a < 0.0001) br.a = rotation_mat(branch.a, rotation) * (rotation_mat(o, angle) * br.a) br.a = norm(vec_vec_mult(br.a, self.gradual_angle)) return br
def resize_primary_brush(self, radius): context = bpy.context primary_brush = self.primary_brush region_height = context.region.height region_width = context.region.width # Determine the world space radius of the primary brush necessary to # project a circle onto the view plane with the specified region space # radius. # Determine the z-depth of the primary brush's center in normalized # device coordinates. projection_matrix = context.region_data.perspective_matrix co = primary_brush.center.copy() co.resize(4) co.w = 1 co.xyzw = projection_matrix * co w = co.w co.xyz /= w NDC_z_depth = co.z # Determine the region space coordinates of the primary brush's center. region_x = (co.x + 1) * region_width / 2 region_y = (co.y + 1) * region_height / 2 # Determine the NDC coordinates of a point on the edge of the # circle that should result from projecting the brush onto the view # plane. co = Vector((region_x, region_y)) + Vector((radius, 0)) co.x = co.x * 2 / region_width - 1 co.y = co.y * 2 / region_height - 1 co.resize(3) co.z = NDC_z_depth # Calculate the world space radius of the primary brush. co.resize(4) co.w = 1 co.xyzw = projection_matrix.inverted() * co w = co.w co.resize(3) co.xyz /= w primary_brush.radius = (co - primary_brush.center).length
def apply_location(self, user): for joint in user.joints.values(): for obj in bpy.data.objects: if obj.type != "ARMATURE": continue armature = obj if not armature.pose: continue pose = armature.pose if not pose.bones: continue bones = pose.bones if joint.name not in bones: continue bone = bones[joint.name] if not bone: continue location = Vector() location.x = joint.location.x location.y = joint.location.y location.z = joint.location.z parent = bone while not hasattr(parent, "parent"): parent = parent.parent if not parent: continue if not hasattr(parent, "location"): continue location.x -= parent.location.x location.y -= parent.location.y location.z -= parent.location.z bone.location = location if bpy.amk2b.recording_started: bone.keyframe_insert(data_path="location", frame=bpy.context.scene.frame_current)
def _frames_difference_vector(self, frames, attr_func): """ Calculates the difference Vector of attribute on the first and the last frame. """ res = Vector((0.0, 0.0, 0.0)) for i in (0, -1): #get attributes from frames[i] v = attr_func(frames[i]) if i == 0: res.y -= v.y res.x -= v.x res.z -= v.z else: res.y += v.y res.x += v.x res.z += v.z if res.x > settings.max_x and res.x < -settings.max_x: res.y = 0 if res.y > settings.max_y and res.y < -settings.max_y: res.y = 0 if res.z > settings.max_z and res.z < -settings.max_z: res.z = 0 return res
def execute(self, context): scene = context.scene sp = scene.speaker scene_objects_set = set(scene.objects) obj = context.active_object # copy cursor location cursor_loc = scene.cursor_location.copy() # snap the cursor to the selected bpy.ops.view3d.snap_cursor_to_selected() channels = self.rows * self.cols # bpy.context for testing. Use context from Op, Panel method. originals = context.selected_objects.copy() # has the selected objects in it. c = {} c["scene"] = scene c["screen"] = context.screen c["area"] = context.area c["region"] = context.region c["active_object"] = None c["edit_object"] = None c["window"] = context.window # c["selected_bases"] = context.selected_bases.copy() # c["selected_editable_objects"] = context.selected_editable_objects.copy() # c["selected_bases"] = [] c["selected_objects"] = originals dimensions = bbdim(selected_bbox(context)) # Location of original unit location = scene.cursor_location.copy() st_handle = bpy.data.objects.new("ST_handle", None) st_handle["channels"] = channels scene.objects.link(st_handle) st_handle.matrix_world.translation = location st_handle["ST_Vis"] = 0 handles = [] new_objects = set(originals) vis = [] # make duplicates for i in range(channels): scene.update() handle = bpy.data.objects.new("ch[%04d]" % i, None) scene.objects.link(handle) handle["ST_Vis"] = i # the channel to drive with. handle.parent = st_handle handles.append(handle) # make the handle the objects parent if no parent else if i: scene_objects_set = set(scene.objects) bpy.ops.object.duplicate(c, 'INVOKE_DEFAULT', linked=False) scene.update() new_objects = set(scene.objects) - scene_objects_set vis.append((i, handle, new_objects)) for i, handle, new_objects in vis: for o in new_objects: print(o, o.parent) if not o.parent or o.parent in handles: o.parent = handle if not i or not o.animation_data: continue # drivers ok for ch0 # get the drivers of o # have speaker as a var target # have CH0 as a variable drivers = o.animation_data.drivers drivers = [d for d in drivers for v in d.driver.variables for t in v.targets if t.id == sp] for d in drivers: all_channels, args = get_driver_settings(d) driver = d.driver expr = driver.expression for ch in all_channels: if len(ch) == 3 and ch.endswith("0"): all_channels.remove(ch) newch = ch.replace("0", str(i)) expr = expr.replace(ch, newch) all_channels.append(newch) var = driver.variables.get(ch) var.name = newch var.targets[0].data_path = var.targets[0].data_path.replace(ch, newch) driver.expression = driver_expr(expr, all_channels, args) # distribute # Properties rows = self.rows cols = self.cols offset = Vector(self.offset) offset.x = dimensions.x * offset.x offset.y = dimensions.y * offset.y offset.z = dimensions.z * offset.z # deselect all bpy.ops.object.select_all(action='DESELECT') self.handle = st_handle is not None self.handle_name = st_handle.name context.scene.objects.active = st_handle st_handle.select = True st_handle["VIS"] = 'GRID' # make an rna and make a grid vis_RNA = { "name": self.handle_name, "rows": self.rows, "cols": self.cols, "channels": channels, "offset": { "x": self.offset[0], "y": self.offset[1], "z": self.offset[2] }, "dimensions": { "x": dimensions[0], "y": dimensions[1], "z": dimensions[2], } } st_handle['_RNA_UI'] = {} st_handle['_RNA_UI']["VIS"] = vis_RNA # make a new edit item in the grids collection grid = context.scene.visualisers.grids.add() grid.name = st_handle.name grid.rows = self.rows grid.cols = self.cols grid.offset = self.offset return {'FINISHED'}
# キーボードのQキーが押された場合は、オブジェクト並進移動モードを終了 if event.type == 'Q' and event.value == 'PRESS': props.running = False print("サンプル3-10: 通常モードへ移行しました。") return {'FINISHED'} //! [refer_prefs] if event.value == 'PRESS': value = Vector((0.0, 0.0, 0.0)) if event.type == prefs.x_axis: value.x = 1.0 if not event.shift else -1.0 if event.type == prefs.y_axis: value.y = 1.0 if not event.shift else -1.0 if event.type == prefs.z_axis: value.z = 1.0 if not event.shift else -1.0 # 選択中のオブジェクトを並進移動する bpy.ops.transform.translate(value=value) //! [refer_prefs] return {'RUNNING_MODAL'} def invoke(self, context, event): props = context.scene.tom_props if context.area.type == 'VIEW_3D': # 開始ボタンが押された時の処理 if props.running is False: props.running = True # modal処理クラスを追加 context.window_manager.modal_handler_add(self) print("サンプル3-2: オブジェクト並進移動モードへ移行しました。")
def scan(numberOfRays, max_distance, elementsPerRay, keep_render_setup, do_shading, rays_buffer, returns_buffer, ELEMENTS_PER_RETURN): if ELEMENTS_PER_RETURN != 8: raise Exception("Scan interface incompatible") # Step 1: Scene to polygons / store face indices and materials tris = [] faces = [] face_array,obj_array,mat_array = scene_to_mesh() for idx,f in enumerate(face_array): tris.append(list(f[0])) tris.append(list(f[1])) tris.append(list(f[2])) faces.append([idx*3,idx*3+1,idx*3+2]) # Step 2: Polygons to BVH tree scene_bvh = BVHTree.FromPolygons(tris, faces, all_triangles = True) # Step 3: Raycast rays scanner = bpy.context.scene.camera reflectivity_distance = scanner.ref_dist reflectivity_limit = scanner.ref_limit reflectivity_slope = scanner.ref_slope origin = Vector([0.0,0.0,0.0]) direction = Vector([0.0,0.0,0.0]) hit_indices = [-1]*numberOfRays for idx in range(numberOfRays): direction.x = rays_buffer[idx*elementsPerRay] direction.y = rays_buffer[idx*elementsPerRay+1] direction.z = rays_buffer[idx*elementsPerRay+2] if elementsPerRay>=6: origin.x = rays_buffer[idx*elementsPerRay+3] origin.y = rays_buffer[idx*elementsPerRay+4] origin.z = rays_buffer[idx*elementsPerRay+5] else: origin.x = bpy.context.scene.camera.location.x origin.y = bpy.context.scene.camera.location.y origin.z = bpy.context.scene.camera.location.z direction.rotate (scanner.matrix_world) (hit_loc, hit_normal, hit_idx, hit_distance) = scene_bvh.ray_cast(origin,direction,max_distance) valid_return = False if hit_loc: mat = mat_array[hit_idx] diffuse_intensity = 1.0 if mat: diffuse_intensity = mat.diffuse_intensity #Calculate the required diffuse reflectivity of the material to create a return ref_limit = blensor_calculate_reflectivity_limit(hit_distance, reflectivity_distance, reflectivity_limit, reflectivity_slope) if diffuse_intensity > ref_limit: valid_return = True if mat: color = mat.diffuse_color returns_buffer[idx*ELEMENTS_PER_RETURN+5] = color.r returns_buffer[idx*ELEMENTS_PER_RETURN+6] = color.g returns_buffer[idx*ELEMENTS_PER_RETURN+7] = color.b else: returns_buffer[idx*ELEMENTS_PER_RETURN+5] = 1.0 returns_buffer[idx*ELEMENTS_PER_RETURN+6] = 1.0 returns_buffer[idx*ELEMENTS_PER_RETURN+7] = 1.0 returns_buffer[idx*ELEMENTS_PER_RETURN] = hit_distance returns_buffer[idx*ELEMENTS_PER_RETURN+1] = hit_loc.x returns_buffer[idx*ELEMENTS_PER_RETURN+2] = hit_loc.y returns_buffer[idx*ELEMENTS_PER_RETURN+3] = hit_loc.z obj = obj_array[hit_idx] name = obj.name returns_buffer[idx*ELEMENTS_PER_RETURN+4] = ord(name[0]) + (ord(name[1])<<8) + (ord(name[2])<<16) + (ord(name[3])<<24) hit_indices[idx] = hit_idx if not valid_return: for r in range(ELEMENTS_PER_RETURN): returns_buffer[idx*ELEMENTS_PER_RETURN+r] = 0.0 # Step 3: Shade rays # TODO: Implement material solver if do_shading: for idx,mat_idx in enumerate(hit_indices): if mat_idx >= 0: #shade hit point pass
def from_object(model, obj, root): node = Mesh(name=obj.name) triangulated_object, created_temp_mesh = create_triangulated_mesh(obj) # apply rotation and scale transform to the object # this ensures that any modifications are baked to the vertices # before we output them to the file triangulated_object.select = True # This is used to transform the vertices and normals of the mesh. world_matrix = model.global_matrix * triangulated_object.matrix_world.copy() mesh = triangulated_object.to_mesh(bpy.context.scene, True, 'PREVIEW') # collect all blender materials used by this mesh for bmaterial in mesh.materials: mat = model.add_material(bmaterial) node.material_id = mat.index cache = VertexCache() bone_data = Mesh.process_armature(model, node, cache, obj) model.bone_data = bone_data weights = [[None]] * len(mesh.vertices) vertices = [] mins = Vector((9999, 9999, 9999)) maxs = Vector((-9999, -9999, -9999)) # build a mapping from group index to bone index total_bones = len(bone_data.ordered_items) if bone_data else 0 group_index_to_bone = [None] * total_bones for group in obj.vertex_groups: # convert group index to boneinfo.index boneinfo = bone_data.find_by_name(group.name) if not boneinfo: # It's possible to have vertex groups for bones which # may have been removed. Ignore these. continue group_index_to_bone[group.index] = boneinfo for index, mv in enumerate(mesh.vertices): position = world_matrix * mv.co vertices.extend([( position[0], position[1], position[2])]) if position[0] < mins.x: mins.x = position[0] elif position[0] > maxs.x: maxs.x = position[0] if position[1] < mins.y: mins.y = position[1] elif position[1] > maxs.y: maxs.y = position[1] if position[2] < mins.z: mins.z = position[2] elif position[2] > maxs.z: maxs.z = position[2] # don't add out of range indices weights[index] = [] for group_element in mv.groups: if group_element.group < total_bones: bone = group_index_to_bone[group_element.group] if bone and group_element.weight > 0.0: if len(weights[index]) < 4: weights[index].append({ "bone": bone.name, "value": group_element.weight }) #else: # print("warning: dropping weight for bone '%s', %2.2f" % (bone.name, group_element.weight)) node.mins = [mins.x, mins.y, mins.z] node.maxs = [maxs.x, maxs.y, maxs.z] mesh.calc_normals_split() normals = [] for loop in mesh.loops: # transform normals normal = (world_matrix.to_3x3() * loop.normal).normalized() normals.append((normal[0], normal[1], normal[2])) mesh.free_normals_split() uvs = [] if not mesh.uv_layers: uv_set = [(0.0, 0.0)] * len(mesh.loops) uvs.append(uv_set) else: for uvlayer in mesh.uv_layers: uv_set = [] print("extracting uv layer: %s" % uvlayer.name) for uvloop in uvlayer.data: uv_set.append([uvloop.uv[0], 1.0-uvloop.uv[1]]) uvs.append(uv_set) colors = [] if not mesh.vertex_colors: # add a default color set color_set = ([(1.0, 1.0, 1.0, 1.0)] * len(mesh.loops)) colors.append(color_set) else: for color_layer in mesh.vertex_colors: color_set = [] print("extracting color layer: %s" % color_layer.name) for data in color_layer.data: color_set.append((data.color[0], data.color[1], data.color[2], 1.0)) colors.append(color_set) if weights: print("total weights: %i, total vertices: %i" % (len(weights), len(vertices))) assert(len(weights) == len(vertices)) # convert and copy geometry over to node cache.populate_with_geometry(vertices, normals, uvs, colors, mesh.loops, weights=weights) node.populate_with_vertex_cache(cache) # de-select the previously selected object triangulated_object.select = False if created_temp_mesh: # remove the triangulated object we created bpy.ops.object.mode_set(mode='OBJECT') bpy.context.scene.objects.unlink(triangulated_object) return node
def write_mesh(context, filepath, use_apply_modifiers, float_precision, include_normals, include_tangents, include_bitangents, include_uvs, include_colors, include_weights, bones_per_vertex, global_matrix, export_skeleton, export_materials, copy_images): # Allocate mesh data vertices = [] vertex_set = set() triangles = [] submeshes = [] bounds_min = Vector((float("inf"), float("inf"), float("inf"))) bounds_max = Vector((-float("inf"), -float("inf"), -float("inf"))) armature = None # Determine vertex format vertex_format = "position" if include_uvs: vertex_format += " uv" if include_normals: vertex_format += " normal" if include_tangents: vertex_format += " tangent" if include_bitangents: vertex_format += " bitangent" if include_colors: vertex_format += " color" if include_weights: vertex_format += " indices%d weights%d" % (bones_per_vertex, bones_per_vertex) # Select objects to export object = context.object try: mesh = object.to_mesh(context.scene, use_apply_modifiers, "PREVIEW") except: return armature = object.parent bm = bmesh.new() bm.from_mesh(mesh) bm.transform(global_matrix * object.matrix_world) bmesh.ops.triangulate(bm, faces=bm.faces) bm.normal_update() uv_layer = bm.loops.layers.uv.active color_layer = bm.loops.layers.color.active deform_layer = bm.verts.layers.deform.active # Sort faces by material faces = bm.faces[:] faces.sort(key=lambda a: a.material_index) # Create empty submesh submesh = Submesh() previous_material_index = -1 for face in faces: triangle_indices = [] # Change material if face.material_index != previous_material_index: # Update primitive count of previous submesh submesh.primitive_count = len(triangles) - (submesh.start_index / 3) # Create a new submesh submesh = Submesh() submesh.material = object.material_slots[face.material_index].material submesh.start_index = len(triangles) * 3 submeshes.append(submesh) previous_material_index = face.material_index for loop in face.loops: vert = loop.vert v = Vertex() v.position = vert.co.copy() if include_normals: if face.smooth: v.normal = vert.normal.copy() else: v.normal = face.normal.copy() if include_uvs and uv_layer is not None: v.uv = loop[uv_layer].uv.copy() if include_colors and color_layer is not None: v.color = loop[color_layer].color.copy() if include_tangents or include_bitangents: tangent_space = calculate_tangent_space(vert, uv_layer) v.tangent = tangent_space[0] v.bitangent = tangent_space[1] if include_weights and deform_layer is not None: # Sort bones by most influential sorted_groups = sorted(vert[deform_layer].items(), key=lambda item: item[1], reverse=True) # Set vertex bone weights and calculate sum weight_total = 0.0 for i in range(min(bones_per_vertex, len(sorted_groups))): vertex_group = object.vertex_groups[sorted_groups[i][0]] bone_index = armature.data.bones.find(vertex_group.name) v.indices[i] = bone_index v.weights[i] = sorted_groups[i][1] weight_total += v.weights[i] # Normalize weights if weight_total > 0.0: v.weights *= 1.0 / weight_total if v not in vertex_set: vertex_set.add(v) triangle_indices.append(len(vertices)) vertices.append(v) # Update bounds bounds_min.x = min(bounds_min.x, v.position.x) bounds_min.y = min(bounds_min.y, v.position.y) bounds_min.z = min(bounds_min.z, v.position.z) bounds_max.x = max(bounds_max.x, v.position.x) bounds_max.y = max(bounds_max.y, v.position.y) bounds_max.z = max(bounds_max.z, v.position.z) else: triangle_indices.append(vertices.index(v)) triangles.append(triangle_indices) # Free BMesh bm.free() # Finalize last submesh submesh.primitive_count = len(triangles) - (submesh.start_index / 3) root_node = AttributeTreeNode() root_node.set_attribute("version", OGF_VERSION_STRING) mesh_node = root_node.create_child() mesh_node.set_attribute("type", "mesh") mesh_node.set_attribute("name", os.path.splitext(os.path.basename(filepath))[0]) mesh_node.set_attribute("vertex_format", vertex_format) mesh_node.set_attribute("vertex_count", str(len(vertices))) # Write vertices vertices_attrib = "" for v in vertices: vertices_attrib += float3_format.format(float_precision, *v.position) + ' ' if include_uvs: vertices_attrib += float2_format.format(float_precision, *v.uv) + ' ' if include_normals: vertices_attrib += float3_format.format(float_precision, *v.normal) + ' ' if include_tangents: vertices_attrib += float3_format.format(float_precision, *v.tangent.xyz) + ' ' if include_bitangents: vertices_attrib += float3_format.format(float_precision, *v.bitangent.xyz) + ' ' if include_colors: vertices_attrib += float3_format.format(float_precision, *v.color) + ' ' if include_weights: for i in range(bones_per_vertex): vertices_attrib += "{} ".format(v.indices[i]) for i in range(bones_per_vertex): vertices_attrib += float_format.format(float_precision, v.weights[i]) + ' ' mesh_node.set_attribute("vertices", vertices_attrib) mesh_node.set_attribute("index_count", str(len(triangles) * 3)) # Write indices indices_attrib = "" for t in triangles: indices_attrib += "{} {} {} ".format(*t) mesh_node.set_attribute("indices", indices_attrib) # Write bounds mesh_node.set_attribute("bounds_min", float3_format.format(float_precision, *bounds_min)) mesh_node.set_attribute("bounds_max", float3_format.format(float_precision, *bounds_max)) # Export skeleton if export_skeleton and object.parent is not None and object.parent.type == "ARMATURE": write_skeleton(filepath, float_precision, global_matrix, object.parent) mesh_node.set_attribute("skeleton", object.parent.name + ".skeleton") for submesh in submeshes: material_filename = submesh.material.name + ".material" submesh_node = mesh_node.create_child() submesh_node.set_attribute("type", "submesh") submesh_node.set_attribute("material", material_filename) submesh_node.set_attribute("primitive_type", "triangle_list") submesh_node.set_attribute("start_index", str(submesh.start_index)) submesh_node.set_attribute("primitive_count", str(int(submesh.primitive_count))) file = open(filepath, "w", encoding="utf8", newline='\n') root_node.serialize(file) file.close() # Export materials if export_materials: for submesh in submeshes: write_material(filepath, copy_images, float_precision, submesh.material)
def make_tetras(cls, vertices): ## 1 : 点群を包含する四面体を求める ## 1-1: 点群を包含する球を求める v_max = Vector((-999, -999, -999)) v_min = Vector(( 999, 999, 999)) for v in vertices: if v_max.x < v.x: v_max.x = v.x if v_max.y < v.y: v_max.y = v.y if v_max.z < v.z: v_max.z = v.z if v_min.x > v.x: v_min.x = v.x if v_min.y > v.y: v_min.y = v.y if v_min.z > v.z: v_min.z = v.z center = (v_max - v_min)*0.5 r = max([(center-v).length for v in vertices]) ## 半径 r += 0.1 ## ちょっとおまけ ## 1-2: 球に外接する四面体を求める v1 = Vector(( center.x , center.y + 3.0*r , center.z )) v2 = Vector(( center.x - 2.0*math.sqrt(2)*r , center.y - r , center.z )) v3 = Vector(( center.x + math.sqrt(2)*r , center.y - r , center.z + math.sqrt(6)*r )) v4 = Vector(( center.x + math.sqrt(2)*r , center.y - r , center.z - math.sqrt(6)*r )) outer = [v1, v2, v3, v4] tetras = [] tetras.append(Tetrahedron(v1, v2, v3, v4)) def to_identifier(tetra): vs = sorted(tetra.vertices, key=lambda v:v.x) a,b,c,d = vs return '{}/{}/{}//{}/{}/{}//{}/{}/{}//{}/{}/{}'.format( a.x,a.y,a.z , b.x,b.y,b.z , c.x,c.y,c.z , d.x,d.y,d.z ) def __scan__(hash_tetras, hash_added, tetra): ide = to_identifier(tetra) if ide in hash_added: if ide in hash_tetras: del hash_tetras[ide] return hash_tetras[ide] = tetra hash_added[ide] = True ## 幾何形状を動的に変化させるための一時リスト for v in vertices: hash_tetras = {} hash_added = {} tmp_tlist = [] for t in tetras: if t.o is not None and t.r > (v - t.o).length: tmp_tlist.append(t) for t1 in tmp_tlist: ## まずそれらを削除 tetras.remove(t1) v1 = t1.vertices[0] v2 = t1.vertices[1] v3 = t1.vertices[2] v4 = t1.vertices[3] __scan__(hash_tetras, hash_added, Tetrahedron(v1, v2, v3, v)) __scan__(hash_tetras, hash_added, Tetrahedron(v1, v2, v4, v)) __scan__(hash_tetras, hash_added, Tetrahedron(v1, v3, v4, v)) __scan__(hash_tetras, hash_added, Tetrahedron(v2, v3, v4, v)) for t in hash_tetras.values(): tetras.append( t ) def cleanup(tetras, t4): for p1 in t4.vertices: for p2 in outer: #if p1.x == p2.x and p1.y == p2.y and p1.z == p2.z: if p1 == p2: tetras.remove(t4) return for t4 in tetras.copy(): cleanup(tetras, t4) return tetras
def execute(self, context): if self.sculpties == []: return {'CANCELLED'} sculpt_bb = {} gmin = None gmax = None edit_mode = context.mode == 'EDIT_MESH' if edit_mode: bpy.ops.object.editmode_toggle() if self.reset_origin: for obj in self.sculpties + self.objects: if 'MIRROR' not in [m.type for m in obj.modifiers]: bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN') for obj in self.sculpties: mesh = obj.to_mesh(context.scene, True, 'RENDER') vmin, vmax = bounding_box(mesh) if not self.reset_origin: vmax.x = max(abs(vmin.x), abs(vmax.x)) vmin.x = -vmax.x vmax.y = max(abs(vmin.y), abs(vmax.y)) vmin.y = -vmax.y vmax.z = max(abs(vmin.z), abs(vmax.z)) vmin.z = -vmax.z if self.aligned: if gmin is None: gmin = Vector((vmin.x, vmin.y, vmin.z)) gmax = Vector((vmax.x, vmax.y, vmax.z)) else: gmin.x = min(gmin.x, vmin.x) gmin.y = min(gmin.y, vmin.y) gmin.z = min(gmin.z, vmin.z) gmax.x = max(gmax.x, vmax.x) gmax.y = max(gmax.y, vmax.y) gmax.z = max(gmax.z, vmax.z) sculpt_bb[obj.name] = (vmin, vmax) if self.use_objects: for obj in self.objects: mesh = obj.to_mesh(context.scene, True, 'RENDER') vmin, vmax = bounding_box(mesh) if gmin is None: gmin = Vector((vmin.x, vmin.y, vmin.z)) gmax = Vector((vmax.x, vmax.y, vmax.z)) else: gmin.x = min(gmin.x, vmin.x) gmin.y = min(gmin.y, vmin.y) gmin.z = min(gmin.z, vmin.z) gmax.x = max(gmax.x, vmax.x) gmax.y = max(gmax.y, vmax.y) gmax.z = max(gmax.z, vmax.z) if not self.reset_origin: gmax.x = max(abs(gmin.x), abs(gmax.x)) gmin.x = -gmax.x gmax.y = max(abs(gmin.y), abs(gmax.y)) gmin.y = -gmax.y gmax.z = max(abs(gmin.z), abs(gmax.z)) gmin.z = -gmax.z for obj_name in sculpt_bb: smin, smax = sculpt_bb[obj_name] if gmin is not None: if self.aligned: vmin = Vector((gmin.x, gmin.y, gmin.z)) vmax = Vector((gmax.x, gmax.y, gmax.z)) else: vmin.x = min(gmin.x, smin.x) vmin.y = min(gmin.y, smin.y) vmin.z = min(gmin.z, smin.z) vmax.x = max(gmax.x, smax.x) vmax.y = max(gmax.y, smax.y) vmax.z = max(gmax.z, smax.z) if self.optimise: # try to improve bake range. Make sure that # any increases don't go beyond the original mesh f = floor((vmax.x - vmin.x) / (smax.x - smin.x)) if f > 1.0: size = (vmax.x - vmin.x) * 0.5 center = vmin.x + size vmin.x = center - size / f vmax.x = center + size / f f = floor((vmax.y - vmin.y) / (smax.y - smin.y)) if f > 1.0: size = (vmax.y - vmin.y) * 0.5 center = vmin.y + size vmin.y = center - size / f vmax.y = center + size / f f = floor((vmax.z - vmin.z) / (smax.z - smin.z)) if f > 1.0: size = (vmax.z - vmin.z) * 0.5 center = vmin.z + size vmin.z = center - size / f vmax.z = center + size / f else: vmin = smin vmax = smax if self.red_scale != 100.0: red_range = vmax.x - vmin.x if self.red_scale == 0.0: red_adjust = red_range / 2.0 else: new_range = red_range * 100.0 / self.red_scale red_adjust = (new_range - red_range) / 2.0 vmin.x -= red_adjust vmax.x += red_adjust if self.green_scale != 100.0: green_range = vmax.y - vmin.y if self.green_scale == 0.0: green_adjust = green_range / 2.0 else: new_range = green_range * 100.0 / self.green_scale green_adjust = (new_range - green_range) / 2.0 vmin.y -= green_adjust vmax.y += green_adjust if self.blue_scale != 100.0: blue_range = vmax.z - vmin.z if self.blue_scale == 0.0: blue_adjust = blue_range / 2.0 else: new_range = blue_range * 100.0 / self.blue_scale blue_adjust = (new_range - blue_range) / 2.0 vmin.z -= blue_adjust vmax.z += blue_adjust bake(bpy.data.objects[obj_name], context.scene, vmin, vmax, self.update_name) for a in context.window.screen.areas: for s in a.spaces: if s.type == 'IMAGE_EDITOR': # force refresh for missing images set to generated if s.image is not None: t = bpy.data.images[s.image.name] s.image = t if a.type == 'IMAGE_EDITOR': a.tag_redraw() if edit_mode: bpy.ops.object.editmode_toggle() if not self.no_dialog: context.scene['sculpty_bake'] = { 'r': self.red_scale, 'g': self.green_scale, 'b': self.blue_scale, 'ro': self.reset_origin, 'uo': self.use_objects, 'a': self.aligned, 'o': self.optimise} return {'FINISHED'}
def main(self, context): obj = context.active_object me = obj.data bm = bmesh.from_edit_mesh(me) face_sets = [] faces = [] force_orthogonal = self.properties.force_orthogonal method = self.properties.method # store data for f in bm.faces: if f.select: if method == 'AVERAGE': faces.append (f) elif method == 'INDIVIDUAL': face_sets.append ([f]) if method == 'AVERAGE': face_sets.append (faces) for fs in face_sets: normal = Vector () center = Vector () for f in fs: normal += f.normal center += f.calc_center_median_weighted () normal.normalize () center /= len (fs) if force_orthogonal: x = abs (normal.x) y = abs (normal.y) z = abs (normal.z) if x > y and x > z: normal.x /= x normal.y = 0.0 normal.z = 0.0 if y > x and y > z: normal.x = 0.0 normal.y /= y normal.z = 0.0 if z > y and z > x: normal.x = 0.0 normal.y = 0.0 normal.z /= z for f in fs: for v in f.verts: d = geometry.distance_point_to_plane (v.co, center, normal) v.co -= normal * d bmesh.update_edit_mesh(me)
def recursive_aabb(facelist, parent, level): """ Recursively build a tree of aabb nodes, returns the root of the subtree. """ # This code is heavily inspired by nwmax and Waylands original code if level > 20: raise RuntimeError("Max recursion depth reached when building aabb " "tree. Look for duplicate faces.") bottom_left = Vector((10000, 10000, 10000)) top_right = Vector((-10000, -10000, -10000)) midpoints = Vector((0, 0, 0)) # First we calculate the bounding box for face in facelist: for x, y, z in face["verts"]: if x < bottom_left.x: bottom_left.x = x if y < bottom_left.y: bottom_left.y = y if z < bottom_left.z: bottom_left.z = z if x > top_right.x: top_right.x = x if y > top_right.y: top_right.y = y if z > top_right.z: top_right.z = z midpoints += face["center"] midpoint = midpoints / len(facelist) bounding_box = {"co1": bottom_left[:], "co2": top_right[:], "index": -1, "left": None, "right": None, "parent": parent} ## If this is a leaf we're done if len(facelist) == 1: bounding_box["index"] = facelist[0]["index"] return bounding_box ## Otherwise we have to decide how to do the splits splits = {"x": {"left": [], "right": []}, "y": {"left": [], "right": []}, "z": {"left": [], "right": []}} #find the best split, which is the split where the two sides are balanced for face in facelist: if face["center"].x < midpoint.x: splits["x"]["left"].append(face) else: splits["x"]["right"].append(face) if face["center"].y < midpoint.y: splits["y"]["left"].append(face) else: splits["y"]["right"].append(face) if face["center"].z < midpoint.z: splits["z"]["left"].append(face) else: splits["z"]["right"].append(face) split = None #We calculate the difference between the two sides delta_x = abs(len(splits["x"]["right"]) - len(splits["x"]["left"])) delta_y = abs(len(splits["y"]["right"]) - len(splits["y"]["left"])) delta_z = abs(len(splits["z"]["right"]) - len(splits["z"]["left"])) # We pick the split where the difference between the splits are as small as possible if delta_x < delta_y and delta_x < delta_z: split = splits["x"] elif delta_y < delta_z: split = splits["y"] else: split = splits["z"] if split["left"]: bounding_box["left"] = recursive_aabb(split["left"], bounding_box, level + 1) if split["right"]: bounding_box["right"] = recursive_aabb(split["right"], bounding_box, level + 1) return bounding_box
def main(filename): sce = bpy.context.scene obs = sce.objects dfaces = {} f = open(filename, 'w') f.write('<?xml version="1.0" encoding="utf-8"?>\n<scene>\n\t<directionalLight>\n\t\t<color r="255" g="255" b="255"/>\n\t\t<direction x="-1" y="-1" z="-1"/>\n\t</directionalLight>\n\t<ambientLight>\n\t\t<color r="255" g="255" b="255"/>\n\t</ambientLight>\n') for ob in obs: if ob.type == 'CAMERA': camz = Vector().to_4d() camy = Vector().to_4d() camy.y = 1 camy.w = 0 camz.z = -10 #camz.w = 0 target = ob.matrix_world * camz normal = ob.matrix_world*camy f.write('\t<camera>\n') f.write('\t\t<position x="%f" y="%f" z="%f"/>\n' %(ob.location.x, ob.location.y, ob.location.z)) f.write('\t\t<target x="%f" y="%f" z="%f"/>\n' %(target.x, target.y, target.z)) f.write('\t\t<normal x="%f" y="%f" z="%f"/>' % (normal.x, normal.y, normal.z)) f.write('\n\t\t<viewplane w="16/2" h="9/2" d="%f"/>\n\t</camera>\n' %(ob.data.lens/4)) if ob.type == 'MESH': dfaces = {} mesh = ob.data verts = mesh.vertices ob_mat = ob.matrix_world scale = Matrix() scale[0][0] = ob.scale.x scale[1][1] = ob.scale.y scale[2][2] = ob.scale.z verts = [ob_mat * scale * vert.co.to_4d() for vert in verts] faces = mesh.polygons for face in faces: material = Material() if len(ob.material_slots) > 0: #print("index", face.material_index) mat = ob.material_slots[face.material_index].material if mat.use_vertex_color_paint: material.color = mesh.vertex_colors[0].data[face.index].color1 else: material.color = mat.diffuse_color if mat.use_transparency: material.transparency= mat.raytrace_transparency.fresnel_factor if mat.use_raytrace: material.reflexivity = mat.raytrace_mirror.reflect_factor material.ambiant = mat.ambient material.diffuse = mat.diffuse_intensity material.specular = mat.specular_intensity material.shininess = mat.specular_hardness if not material in dfaces: dfaces[material] = [] dfaces[material].append(face) for material in dfaces: f.write("\t<object>\n") f.write('\t\t<shape>\n') f.write('\t\t\t<list>\n') for face in dfaces[material]: vs = face.vertices if len(vs)==3: writeTriangle(f, mesh.vertices, verts, vs, material) elif len(vs)==4: vs1 = vs[:3] vs2 = [vs[0],vs[2], vs[3]] writeTriangle(f, mesh.vertices, verts, vs1, material) writeTriangle(f, mesh.vertices, verts, vs2, material) else: print("Pas de face") f.write('\t\t\t</list>\n') f.write('\t\t</shape>\n') f.write('\t\t<material>\n\t\t\t<phong>\n') f.write('\t\t\t\t<color r="%d" g="%d" b="%d"/>\n' % (int(255*material.color.r), int(255*material.color.g), int(255*material.color.b))) f.write('\t\t\t\t<specular v="%f"/>\n' % (material.specular)) f.write('\t\t\t\t<diffuse v="%f"/>\n' % (material.diffuse)) f.write('\t\t\t\t<ambiant v="%f"/>\n' % (material.ambiant)) f.write('\t\t\t\t<shininess v="%f"/>\n' % (material.shininess)) f.write('\t\t\t\t<reflexivity v="%f"/>\n' % (material.reflexivity)) f.write('\t\t\t\t<transparency v="%f"/>\n' % (material.transparency)) f.write('\t\t\t</phong>\n\t\t</material>\n') f.write("\t</object>\n") f.write("</scene>") f.close() print ("\nExport to PRay xml completed.") return {'FINISHED'}