Blender-用代码建模-003-简单绘制

顶点Path

仿照Qt中的PainterPath，实现顶点Path，用来绘制图形。

# 基本接口
class VertexPath:
	def begin_path(self, pos = None, path_attr = PathAttr()):
	def new_path(self, pos = None, path_attr = PathAttr()):
	def end_path(self, pos = None):
	def move_to(self, pos):
	def quad_to(self, ctr_point, end_pos, samples = 16):
	def cubic_to(self, ctr_point1, ctr_point2, end_pos, samples=32):
	def circle_to(self, center, normal, radius, samples = 32, rot_offset_deg=0):
	def arc_to(self, center, normal, angle_deg, samples = 32, bin=None, start = None):
	def rect_to(self, center, width, height, h_axis, normal=None):
	def rounded_rect_to(self, center, width, height, h_axis, normal=None, radii=(0.2,), samples = 8):
    def polygon_to(self, points):
    def ellipse_to(self, center, width, height, h_axis, normal=None, samples=64):

# 完整代码
######## Util ########
def vec_mul(v1, v2):
    return Vector(x * y for x, y in zip(v1, v2))

def rotation_between(v1, v2, normal=None):
    ang = math.degrees(v1.angle(v2))
    if normal is not None and abs(ang-180) < 0.0001:
        return Quaternion(normal, math.radians(ang))
    return v1.rotation_difference(v2)
######## Util ########

class VertexPath:
    
    class PathAttr:
        def __init__(self, closed = True):
            self.closed = closed
    
    def __init__(self):
        self.direction = None
        self.pos = None
        self.vert_series = VertexSeries()
        self.cur_verts = []
        self.began = False
        self.path_attrs = []
        
    def begin_path(self, pos = None, path_attr = PathAttr()):
        if self.began:
            print('path already began')
            return
        self.began = True
        self.vert_series.add_verts(self.cur_verts)
        if pos is not None:
            self.move_to(pos)
        self.path_attrs.append(path_attr)
        return self
    
    def new_path(self, pos = None, path_attr = PathAttr()):
        self.end_path()
        self.begin_path(pos, path_attr)
        return self
        
    def end_path(self, pos = None):
        if not self.began:
            print('path has not began yet')
            return
        if pos is not None:
            self.move_to(pos)
        self.began = False
        self.cur_verts = []
        return self
        
    def ensure_began(self):
        if not self.began:
            print('path has not began yet')
            return False
        return True
    
    def update_pos(self, pos):
        last_pos = self.pos
        self.pos = pos
        if last_pos is not None:
            self.direction = (Vector(self.pos) - Vector(last_pos)).normalized().to_tuple()
    
    def move_to(self, pos):
        if not self.ensure_began():
            return
        assert pos is not None
        self.cur_verts.append(pos)
        self.update_pos(pos)
        return self
    
    def quad_to(self, ctr_point, end_pos, samples = 16):
        if not self.ensure_began():
            return
        if self.pos is None:
            self.update_pos( (0, 0, 0) )
        delta_t = 1.0 / (samples-1)
        for i in range(samples):
            t = delta_t * i
            sample = (1-t)*(1-t)*Vector(self.pos) \
                    + 2* t * (1-t) * Vector(ctr_point) \
                    + t * t * Vector(end_pos)
            self.cur_verts.append(sample.to_tuple())
            if i == samples - 1:
                self.update_pos(sample.to_tuple())
        return self
    
    def cubic_to(self, ctr_point1, ctr_point2, end_pos, samples=32):
        if not self.ensure_began():
            return
        if self.pos is None:
            self.update_pos( (0, 0, 0) )
        delta_t = 1.0 / (samples-1)
        for i in range(samples):
            t = delta_t * i
            sample = (1-t)*(1-t)*(1-t)*Vector(self.pos) \
                + 3 * (1-t)*(1-t)*t*Vector(ctr_point1) \
                + 3 * (1-t)*t*t*Vector(ctr_point2) \
                + t * t * t * Vector(end_pos)
            self.cur_verts.append(sample.to_tuple())    
            if i == samples - 1:
                self.update_pos(sample.to_tuple())
        return self
    
    def circle_to(self, center, normal, radius, samples = 32, rot_offset_deg=0):
        if not self.ensure_began():
            return
        assert samples >= 3
        delta_deg = 360 / samples
        
        z = Vector( normal ).normalized()
        from_z = Vector( (0,0,1) )
        z_diff = from_z.rotation_difference(z)
        x = z_diff * Vector( (1, 0, 0) )
        y = z_diff * Vector( (0, 1, 0) )
        transform = Matrix( [x, y, z, center] )
        
        # proj to plane
        ini_vec = Vector( (1, 0, 0) ) * radius
        for i in range(samples):
            deg = delta_deg * i + rot_offset_deg
            rad = math.radians(deg)
            q = Quaternion( Vector( (0, 0, 1) ), rad )
            vec = q * ini_vec
            p = (vec * transform).to_tuple()
            self.cur_verts.append( p )
            if i == samples - 2:
                self.pos = p
            elif i == samples - 1:
                self.update_pos(p)
        return self
    
    def arc_to(self, center, normal, angle_deg, samples = 32, bin=None, start = None):
        if not self.ensure_began():
            return
        assert self.pos is not None
        ini_vec = Vector( self.pos if start is None else start) - Vector( center )
        delta_deg = angle_deg / samples
        for i in range(1, samples):
            deg = delta_deg * i
            rad = math.radians(deg)
            q = Quaternion( normal, rad )
            vec = q * ini_vec
            p = (Vector( center ) + vec).to_tuple()
            if bin is not None:
                bin.append( p )
            else:
                self.cur_verts.append( p )
                if i == samples - 2:
                    self.pos = p
                elif i == samples - 1:
                    self.update_pos(p)
        return self
            
    
    def rect_to(self, center, width, height, h_axis, normal=None):
        center = Vector( center )
        left_top = Vector( (-width/2, -height/2, 0) )
        right_top = Vector( (width/2, -height/2, 0) )
        right_down = Vector( (width/2, height/2, 0) )
        left_down = Vector( (-width/2, height/2, 0) )
        y = Vector( h_axis ).normalized()
        from_y = Vector( (0, 1, 0) )
        #q_diff = from_y.rotation_difference(y)
        q_diff = rotation_between(from_y, y, normal)
        x = q_diff * Vector( (1, 0, 0) ).normalized()
        z = q_diff * Vector( (0, 0, 1) ).normalized()
        transform = Matrix( [x, y, z, center] )
        left_top = left_top * transform
        right_top = right_top * transform
        right_down = right_down * transform
        left_down = left_down * transform
        self.cur_verts += [left_top, right_top, right_down, left_down]
        return self
    
    def rounded_rect_to(self, center, width, height, h_axis, normal=None, radii=(0.2,), samples = 8):
        center = Vector( center )
        left_top = Vector( (-width/2, -height/2, 0) )
        right_top = Vector( (width/2, -height/2, 0) )
        right_down = Vector( (width/2, height/2, 0) )
        left_down = Vector( (-width/2, height/2, 0) )
        
        if len(radii) == 1:
            radii += radii
            radii += radii
        else:
            while len(radii) != 4:
                radii += 0,
        min_edge = min(width, height) / 2
        
        threshold = 0.001
        tmp_center = None
        tmp_verts = []
        
        starts = [left_top + Vector( (0, min_edge * radii[0], 0) ),
                right_top + Vector( (-min_edge * radii[1], 0, 0) ),
                right_down + Vector( (0, -min_edge * radii[2], 0) ),
                left_down + Vector( (min_edge * radii[3], 0, 0) )
                ]
        tmp_center_diffs = [ Vector( (min_edge * radii[0], 0, 0) ),
                Vector( (0, min_edge * radii[1], 0) ),
                Vector( (-min_edge * radii[2], 0, 0) ),
                Vector( (0, -min_edge * radii[3], 0) )
                ]
        for i in range(4):
            start = starts[i]
            tmp_verts.append(start)
            if radii[i] > threshold:
                tmp_center = start + tmp_center_diffs[i]
                self.arc_to(start=start, bin=tmp_verts, normal=(0, 0, 1), center=tmp_center, angle_deg=90, samples=samples)
        
        y = Vector( h_axis ).normalized()
        from_y = Vector( (0, 1, 0) )
        #q_diff = from_y.rotation_difference(y)
        q_diff = rotation_between(from_y, y)
        x = q_diff * Vector( (1, 0, 0) ).normalized()
        z = q_diff * Vector( (0, 0, 1) ).normalized()
        transform = Matrix( [x, y, z, center] )
        
        for i in range(len(tmp_verts)):
            self.cur_verts.append( Vector( tmp_verts[i] ) * transform )
        
        return self
    
    def polygon_to(self, points):
        if not self.ensure_began():
            return
        for p in points:
            self.move_to(p)
        return self
    
    def ellipse_to(self, center, width, height, h_axis, normal=None, samples=64):
        if not self.ensure_began():
            return
        assert samples >= 3
        delta_deg = 360 / samples
        
        tmp_verts = []
        for i in range(samples):
            deg = delta_deg * i
            rad = math.radians(deg)
            q = Quaternion( (0, 0, 1), rad )
            vec = vec_mul( q * Vector( (0, height/2, 0) ), Vector( (width / height,1,1) ))
            p = Vector( center ) + vec
            tmp_verts.append(p)
            
        y = Vector( h_axis ).normalized()
        from_y = Vector( (0, 1, 0) )
        q_diff = rotation_between(from_y,y, normal)
        x = q_diff * Vector( (1, 0, 0) ).normalized()
        z = q_diff * Vector( (0, 0, 1) ).normalized()
        transform = Matrix( [x, y, z, center] )
            
        for i in range(samples):
            p = (transform * tmp_verts[i]).xyz.to_tuple()
            self.cur_verts.append( p )
            if i == samples - 2:
                self.pos = p
            elif i == samples - 1:
                self.update_pos(p)
        return self

用法

import bpy
import math
import random
from mathutils import Quaternion
from mathutils import Vector
from mathutils import Matrix
# select all
bpy.ops.object.select_all(action='SELECT')
# delete selected
bpy.ops.object.delete(use_global=False)

# 由顶点数组构成的序列
class VertexSeries:
    def __init__(self):
        self.verts = []
    # 由顶点数组序列生成面数组
    def create_verts_and_faces(self):
        verts = []
        faces = []
        now_index = 0
        for i in range(len(self.verts)):
            now_verts = self.verts[i]
            verts += now_verts
            if i > 0:
                last_verts = self.verts[i-1]
                last_index = now_index - len(last_verts)
                for i in range(0, len(last_verts) - 1):
                    last_i = last_index + i
                    now_i = now_index + i
                    face = (last_i, last_i+1, now_i+1, now_i)
                    faces.append(face)
            now_index += len(now_verts)
        return (verts, faces)
    
    def create_verts_and_edges(self, path_attrs):
        verts = []
        edges = []
        now_index = 0
        for i in range(len(self.verts)):
            now_verts = self.verts[i]
            verts += now_verts
            first_index = now_index
            for j in range(len(now_verts)):
                if j > 0:
                    edges.append( (now_index-1 , now_index) )
                now_index += 1
            if path_attrs[i].closed:
                edges.append( (now_index - 1, first_index) )
        return (verts, edges)
            
    # 向序列中加入顶点数组
    def add_verts(self, verts):
        self.verts.append(verts)

######## Util ########
# ....
######## Util ########

class VertexPath:
    # ....
        
def create_obj(mesh):
    meshobj = bpy.data.objects.new('object', mesh)
    bpy.context.scene.objects.link(meshobj)

path = VertexPath()
# 绘制八卦
def draw_gua(path, radius = 2):
    def draw_part_gua(path, gua, is_positive, center, orientation, width, height):
        if not is_positive:
            path.new_path().rect_to(center, width, height, orientation, normal=(0,0,1))
        else:
            gap = 0.15 * width
            width = (width-gap)/2
            direction = Vector( (orientation[1], -orientation[0], orientation[2]) ).normalized()
            center_left = center + direction * ((width+gap)/2)
            center_right = center - direction * ((width+gap)/2)
            path.new_path().rect_to(center_left, width, height, orientation, normal=(0,0,1))
            path.new_path().rect_to(center_right, width, height, orientation, normal=(0,0,1))
    gua_table = [0b000, 0b100, 0b101, 0b110, 0b111, 0b011, 0b010, 0b001]
    ini_vec = Vector( (0, 1, 0) )
    width = 0.9
    height = 0.2
    for index, gua in enumerate(gua_table):
        rad = math.radians( index * (360/8) )
        q = Quaternion( Vector( (0, 0, 1) ), rad)
        direction = (q * ini_vec)
        center = direction * radius
        draw_part_gua(path, gua, gua & 0b100, center, direction, width, height)
        center = center + direction * height * 1.4
        draw_part_gua(path, gua, gua & 0b010, center, direction, width, height)
        center = center + direction * height * 1.4
        draw_part_gua(path, gua, gua & 0b001, center, direction, width, height)

path.begin_path()\
    .circle_to(center=(0,0,0), radius=1.3,normal=(0,0,1), samples=64)\
    .new_path()\
    .circle_to(center=(0.55,0.6, 0), radius=0.1, normal=(0,0,1))\
    .new_path()\
    .circle_to(center=(-0.55,-0.6, 0), radius=0.1, normal=(0,0,1))\
    .new_path(pos=(0,1.3,0),path_attr=VertexPath.PathAttr(closed=False))\
    .cubic_to(ctr_point1=(-1.1, 0.3, 0), ctr_point2=(1.1, -0.3, 0), end_pos=(0,-1.3,0), samples=64)\
    
draw_gua(path)

path.new_path()\
    .circle_to(center=(0,0,0), radius=3.2, normal=(0,0,1), samples=8, rot_offset_deg=22.5)\
    .new_path()\
    .circle_to(center=(0,0,0), radius=3.4, normal=(0,0,1), samples=8, rot_offset_deg=22.5)  

path.end_path()
# 绘制完成，创建mesh
verts_and_edges = path.vert_series.create_verts_and_edges(path.path_attrs)
mesh = bpy.data.meshes.new('mesh')
mesh.from_pydata(verts_and_edges[0],verts_and_edges[1], [])
mesh.update()
meshobj = bpy.data.objects.new('object', mesh)
bpy.context.scene.objects.link(meshobj)

效果