コード例 #1
0
ファイル: paint_moveUV.py プロジェクト: Italic-/blenderpython
def find_uv(context):
    obj_data = bmesh.from_edit_mesh(context.object.data)
    l = []
    first = 0
    diff = 0
    for f, face in enumerate(obj_data.faces):
        for v, vertex in enumerate(face.verts):
            if vertex.select:
                l.append([f, v])
                if first == 0:
                    v1 = vertex.link_loops[0].vert.co
                    sv1 = loc3d2d(context.region, context.space_data.region_3d, v1)
                    v2 = vertex.link_loops[0].link_loop_next.vert.co
                    sv2 = loc3d2d(context.region, context.space_data.region_3d, v2)
                    vres = sv2 - sv1
                    va = vres.angle(Vector((0.0, 1.0)))

                    uv1 = vertex.link_loops[0][obj_data.loops.layers.uv.active].uv
                    uv2 = vertex.link_loops[0].link_loop_next[obj_data.loops.layers.uv.active].uv
                    uvres = uv2 - uv1
                    uva = uvres.angle(Vector((0.0, 1.0)))
                    diff = uva - va
                    first += 1

    return l, diff
コード例 #2
0
ファイル: paint_moveUV.py プロジェクト: yazici/blenderpython
def find_uv(context):
    obj_data = bmesh.from_edit_mesh(context.object.data)
    l = []
    first = 0
    diff = 0
    for f, face in enumerate(obj_data.faces):
        for v, vertex in enumerate(face.verts):
            if vertex.select:
                l.append([f, v])
                if first == 0:
                    v1 = vertex.link_loops[0].vert.co
                    sv1 = loc3d2d(context.region, context.space_data.region_3d,
                                  v1)
                    v2 = vertex.link_loops[0].link_loop_next.vert.co
                    sv2 = loc3d2d(context.region, context.space_data.region_3d,
                                  v2)
                    vres = sv2 - sv1
                    va = vres.angle(Vector((0.0, 1.0)))

                    uv1 = vertex.link_loops[0][
                        obj_data.loops.layers.uv.active].uv
                    uv2 = vertex.link_loops[0].link_loop_next[
                        obj_data.loops.layers.uv.active].uv
                    uvres = uv2 - uv1
                    uva = uvres.angle(Vector((0.0, 1.0)))
                    diff = uva - va
                    first += 1

    return l, diff
コード例 #3
0
ファイル: mesh_vertex_slide.py プロジェクト: mik0001/Blender
 def ScreenDistance(self, vertex_zero_co, vertex_one_co):
     matw = bpy.context.active_object.matrix_world
     V0 = matw * vertex_zero_co
     res0 = loc3d2d(bpy.context.region, bpy.context.space_data.region_3d, V0)
     V1 = matw * vertex_one_co
     res1 = loc3d2d(bpy.context.region, bpy.context.space_data.region_3d, V1)
     result = (res0 - res1).length
     return result
コード例 #4
0
def draw_tetrahedron(region, rv3d, context, tetra_coords):
    apex, base1, base2, base3 = tetra_coords

    # converting to screen coordinates
    screen_apex = loc3d2d(region, rv3d, apex)
    screen_base1 = loc3d2d(region, rv3d, base1) 
    screen_base2 = loc3d2d(region, rv3d, base2)
    screen_base3 = loc3d2d(region, rv3d, base3)
    
    # colour + line setup, 50% alpha, 1 px width line
    bgl.glEnable(bgl.GL_BLEND)
    bgl.glLineWidth(1)
        

    # linear distance line
    bgl.glColor4f(0.6, 0.6, 0.6, 0.8)
    bgl.glBegin(bgl.GL_LINES)
    bgl.glVertex2f(*screen_apex)  
    bgl.glVertex2f(*screen_base3)  
    bgl.glEnd()

    # x
    bgl.glColor4f(1.0, 0.1, 0.1, 0.8)
    bgl.glBegin(bgl.GL_LINES)  
    bgl.glVertex2f(*screen_base3)  
    bgl.glVertex2f(*screen_base2)
    bgl.glEnd()

    # y
    bgl.glColor4f(0.0, 1.0, 0.1, 0.8)    
    bgl.glBegin(bgl.GL_LINES)  
    bgl.glVertex2f(*screen_base2)
    bgl.glVertex2f(*screen_base1)  
    bgl.glEnd()

    # z
    bgl.glColor4f(0.1, 0.3, 1.0, 0.8)
    bgl.glBegin(bgl.GL_LINES)  
    bgl.glVertex2f(*screen_apex)  
    bgl.glVertex2f(*screen_base1)  
    bgl.glEnd()

    # distraction line 1 & 2  
    bgl.glColor4f(0.3, 0.3, 0.3, 0.6)
    bgl.glLineStipple(4, 0x5555) 
    bgl.glEnable(bgl.GL_LINE_STIPPLE) 

    bgl.glBegin(bgl.GL_LINES)  
    bgl.glVertex2f(*screen_apex)  
    bgl.glVertex2f(*screen_base2)  
    bgl.glVertex2f(*screen_base1)  
    bgl.glVertex2f(*screen_base3)  
    bgl.glEnd()

    # done    
    bgl.glDisable(bgl.GL_LINE_STIPPLE)
    bgl.glEnable(bgl.GL_BLEND)  # back to uninterupted lines
コード例 #5
0
def draw_tetrahedron(region, rv3d, context, tetra_coords):
    apex, base1, base2, base3 = tetra_coords

    # converting to screen coordinates
    screen_apex = loc3d2d(region, rv3d, apex)
    screen_base1 = loc3d2d(region, rv3d, base1)
    screen_base2 = loc3d2d(region, rv3d, base2)
    screen_base3 = loc3d2d(region, rv3d, base3)

    # colour + line setup, 50% alpha, 1 px width line
    bgl.glEnable(bgl.GL_BLEND)
    bgl.glLineWidth(1)

    # linear distance line
    bgl.glColor4f(0.6, 0.6, 0.6, 0.8)
    bgl.glBegin(bgl.GL_LINES)
    bgl.glVertex2f(*screen_apex)
    bgl.glVertex2f(*screen_base3)
    bgl.glEnd()

    # x
    bgl.glColor4f(1.0, 0.1, 0.1, 0.8)
    bgl.glBegin(bgl.GL_LINES)
    bgl.glVertex2f(*screen_base3)
    bgl.glVertex2f(*screen_base2)
    bgl.glEnd()

    # y
    bgl.glColor4f(0.0, 1.0, 0.1, 0.8)
    bgl.glBegin(bgl.GL_LINES)
    bgl.glVertex2f(*screen_base2)
    bgl.glVertex2f(*screen_base1)
    bgl.glEnd()

    # z
    bgl.glColor4f(0.1, 0.3, 1.0, 0.8)
    bgl.glBegin(bgl.GL_LINES)
    bgl.glVertex2f(*screen_apex)
    bgl.glVertex2f(*screen_base1)
    bgl.glEnd()

    # distraction line 1 & 2
    bgl.glColor4f(0.3, 0.3, 0.3, 0.6)
    bgl.glLineStipple(4, 0x5555)
    bgl.glEnable(bgl.GL_LINE_STIPPLE)

    bgl.glBegin(bgl.GL_LINES)
    bgl.glVertex2f(*screen_apex)
    bgl.glVertex2f(*screen_base2)
    bgl.glVertex2f(*screen_base1)
    bgl.glVertex2f(*screen_base3)
    bgl.glEnd()

    # done
    bgl.glDisable(bgl.GL_LINE_STIPPLE)
    bgl.glEnable(bgl.GL_BLEND)  # back to uninterupted lines
コード例 #6
0
 def ScreenDistance(self, vertex_zero_co, vertex_one_co):
     matw = bpy.context.active_object.matrix_world
     V0 = matw * vertex_zero_co
     res0 = loc3d2d(bpy.context.region, bpy.context.space_data.region_3d,
                    V0)
     V1 = matw * vertex_one_co
     res1 = loc3d2d(bpy.context.region, bpy.context.space_data.region_3d,
                    V1)
     result = (res0 - res1).length
     return result
コード例 #7
0
ファイル: viewer_matrix.py プロジェクト: elfnor/sverchok
def screen_v3dBGL_overlay(context, args):

    if not args[2]:
        return

    alpha = args[3]
    

    region = context.region
    region3d = context.space_data.region_3d

    bgl.glEnable(bgl.GL_BLEND)
    bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)

    for matrix, color in args[0]:
        r, g, b = color
        bgl.glColor4f(r, g, b, alpha)
        bgl.glBegin(bgl.GL_QUADS)
        M = Matrix(matrix)
        for x, y in [(-.5, .5), (.5 ,.5), (.5 ,-.5), (-.5 ,-.5)]:
            vector3d = M * Vector((x, y, 0))
            vector2d = loc3d2d(region, region3d, vector3d)
            bgl.glVertex2f(*vector2d)

        bgl.glEnd()

    # restore opengl defaults
    bgl.glLineWidth(1)
    bgl.glDisable(bgl.GL_BLEND)
    bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
コード例 #8
0
def screen_v3dBGL_overlay(context, args):

    if not args[2]:
        return

    alpha = args[3]

    region = context.region
    region3d = context.space_data.region_3d

    bgl.glEnable(bgl.GL_BLEND)
    bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)

    for matrix, color in args[0]:
        r, g, b = color
        bgl.glColor4f(r, g, b, alpha)
        bgl.glBegin(bgl.GL_QUADS)
        M = Matrix(matrix)
        for x, y in [(-.5, .5), (.5, .5), (.5, -.5), (-.5, -.5)]:
            vector3d = M * Vector((x, y, 0))
            vector2d = loc3d2d(region, region3d, vector3d)
            bgl.glVertex2f(*vector2d)

        bgl.glEnd()

    # restore opengl defaults
    bgl.glLineWidth(1)
    bgl.glDisable(bgl.GL_BLEND)
    bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
コード例 #9
0
ファイル: snippet.py プロジェクト: szabo92/gistable
def draw_data(self, context):

    region = context.region
    rv3d = context.space_data.region_3d
    obj = context.active_object
    vertlist = obj.data.vertices

    edge_list = []
    for edge in obj.data.edges:
        idx1, idx2 = edge.vertices[:]
        co1, co2 = vertlist[idx1].co, vertlist[idx2].co
        co2d_1 = loc3d2d(region, rv3d, co1)
        co2d_2 = loc3d2d(region, rv3d, co2)
        edge_list.append((co2d_1, co2d_2))

    write_svg(edge_list, region)
    return
コード例 #10
0
 def draw_gl_strip(coords, line_thickness):
     bgl.glLineWidth(line_thickness)
     bgl.glBegin(bgl.GL_LINES)
     for coord in coords:
         vector3d = matrix_world * coord
         vector2d = loc3d2d(region, rv3d, vector3d)
         bgl.glVertex2f(*vector2d)
     bgl.glEnd()
コード例 #11
0
ファイル: bvp_to_svg.py プロジェクト: mitsu600/rawr
def generate_2d_draw_list(unique_set, context):

    region, rv3d, obj, vertlist = get_locals(context)

    edge_list = []
    for edge in unique_set:
        local_coords = [vertlist[idx].co for idx in edge]
        world_coords = [obj.matrix_world * point for point in local_coords]    
        edge_as_2d = [loc3d2d(region, rv3d, point) for point in world_coords]
        edge_list.append(edge_as_2d)

    return edge_list, region
コード例 #12
0
def draw_callback_px(self, context):
    """Modally called function that draws the lines as they are streamed.
    Firstly updates the viewport's text.
    Then draws the line based on points in self.point_path.
    """
    print("data points", len(self.point_path))

    # get region so can draw intermediate lines
    region = context.region
    rv3d = context.space_data.region_3d


    draw_text_on_viewport("{} vertices added, timestamp {}"
                          .format(str(len(self.point_path)), str(self.latest_ts)))
    # set the line parameters
    # 50% alpha, 2 pixel width line
    bgl.glEnable(bgl.GL_BLEND)
    bgl.glColor4f(0.0, 0.0, 0.0, 0.5)
    bgl.glLineWidth(2)

    # draw the line here.....
    bgl.glBegin(bgl.GL_LINE_STRIP)
    # start from the origin for visual purposes
    for i in [0]:
        vertex = loc3d2d(region, rv3d, (i, i, i))
        print('vertex is', vertex)
        bgl.glVertex2f(vertex[0], vertex[1])

    for i, loc3d in enumerate(self.point_path):
        loc2d = loc3d2d(region, rv3d, loc3d)
        print(loc2d[0], loc2d[1], 'is the viewport coordinates')
        bgl.glVertex2i(math.floor(loc2d[0]), math.floor(loc2d[1]))
        #bgl.glVertex2i(math.floor(loc2d[0]%10), math.floor(loc2d[1]%10))

    bgl.glEnd()

    # restore opengl defaults
    bgl.glLineWidth(1)
    bgl.glDisable(bgl.GL_BLEND)
    bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
コード例 #13
0
def draw_callback_px(self, context):
    """Modally called function that draws the lines as they are streamed.
    Firstly updates the viewport's text.
    Then draws the line based on points in self.point_path.
    """
    print("data points", len(self.point_path))

    # get region so can draw intermediate lines
    region = context.region
    rv3d = context.space_data.region_3d

    draw_text_on_viewport("{} vertices added, timestamp {}".format(
        str(len(self.point_path)), str(self.latest_ts)))
    # set the line parameters
    # 50% alpha, 2 pixel width line
    bgl.glEnable(bgl.GL_BLEND)
    bgl.glColor4f(0.0, 0.0, 0.0, 0.5)
    bgl.glLineWidth(2)

    # draw the line here.....
    bgl.glBegin(bgl.GL_LINE_STRIP)
    # start from the origin for visual purposes
    for i in [0]:
        vertex = loc3d2d(region, rv3d, (i, i, i))
        print('vertex is', vertex)
        bgl.glVertex2f(vertex[0], vertex[1])

    for i, loc3d in enumerate(self.point_path):
        loc2d = loc3d2d(region, rv3d, loc3d)
        print(loc2d[0], loc2d[1], 'is the viewport coordinates')
        bgl.glVertex2i(math.floor(loc2d[0]), math.floor(loc2d[1]))
        #bgl.glVertex2i(math.floor(loc2d[0]%10), math.floor(loc2d[1]%10))

    bgl.glEnd()

    # restore opengl defaults
    bgl.glLineWidth(1)
    bgl.glDisable(bgl.GL_BLEND)
    bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
コード例 #14
0
def draw_linear_line(region, rv3d, context, coordinate_list):
   
    # 50% alpha, 2 pixel width line
    bgl.glEnable(bgl.GL_BLEND)
    
    bgl.glColor4f(0.7, 0.7, 0.7, 0.5)
    bgl.glLineWidth(1)
    
    bgl.glBegin(bgl.GL_LINE_STRIP)
    for coord in coordinate_list:
        vector3d = (coord.x, coord.y, coord.z)
        vector2d = loc3d2d(region, rv3d, vector3d)
        bgl.glVertex2f(*vector2d)
    bgl.glEnd()
コード例 #15
0
def draw_linear_line(region, rv3d, context, coordinate_list):

    # 50% alpha, 2 pixel width line
    bgl.glEnable(bgl.GL_BLEND)

    bgl.glColor4f(0.7, 0.7, 0.7, 0.5)
    bgl.glLineWidth(1)

    bgl.glBegin(bgl.GL_LINE_STRIP)
    for coord in coordinate_list:
        vector3d = (coord.x, coord.y, coord.z)
        vector2d = loc3d2d(region, rv3d, vector3d)
        bgl.glVertex2f(*vector2d)
    bgl.glEnd()
コード例 #16
0
ファイル: bvp_to_svg.py プロジェクト: mitsu600/rawr
def generate_2d_draw_data(context):
    """
    this gets vertex coordinates, converts local to global
    generates edge_list with 2d screen coordinates.
    """
    region, rv3d, obj, vertlist = get_locals(context)

    edge_list = []
    for edge in obj.data.edges:
        local_coords = [vertlist[idx].co for idx in edge.vertices]
        world_coords = [obj.matrix_world * point for point in local_coords]    
        edge_as_2d = [loc3d2d(region, rv3d, point) for point in world_coords]
        edge_list.append(edge_as_2d)

    return edge_list, region
    def draw_index(rgb, index, coord):

        vector3d = matrix_world * coord
        x, y = loc3d2d(region, rv3d, vector3d)

        index = str(index)
        polyline = get_points(index)
        ''' draw polygon '''
        bgl.glColor4f(0.103, 0.2, 0.2, 0.2)
        bgl.glBegin(bgl.GL_POLYGON)
        for pointx, pointy in polyline:
            bgl.glVertex2f(pointx + x, pointy + y)
        bgl.glEnd()
        ''' draw text '''
        txt_width, txt_height = blf.dimensions(0, index)
        bgl.glColor3f(*rgb)
        blf.position(0, x - (txt_width / 2), y - (txt_height / 2), 0)
        blf.draw(0, index)
コード例 #18
0
def draw_points(context, points, size, gl_col):
    region = context.region
    rv3d = context.space_data.region_3d

    bgl.glEnable(bgl.GL_POINT_SMOOTH)
    bgl.glPointSize(size)
    bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)

    bgl.glBegin(bgl.GL_POINTS)
    bgl.glColor4f(*gl_col)
    for coord in points:
        vector3d = (coord.x, coord.y, coord.z)
        vector2d = loc3d2d(region, rv3d, vector3d)
        bgl.glVertex2f(*vector2d)
    bgl.glEnd()

    bgl.glDisable(bgl.GL_POINT_SMOOTH)
    bgl.glDisable(bgl.GL_POINTS)
    return
コード例 #19
0
    def draw_callback_px(self, context):
        x, y = loc3d2d(context.region, context.space_data.region_3d, self.bm.verts[self.ActiveVertex].co)

        # Draw an * at the active vertex
        blf.position(0, x, y, 0)
        blf.size(0, 26, 72)
        blf.draw(0, "*")

        #Draw Help
        yPos=30
        blf.size(0, 11, context.user_preferences.system.dpi)
        txtHelp1 = "{SHIFT}:Precision"
        txtHelp2 = "{WHEEL}:Change the vertex/edge"
        txtHelp3 = "{ALT}:Continuos slide"
        txtHelp4 = "{LEFT ARROW}:Reverse the movement"
        txtHelp5 = "{RIGHT ARROW}:Restore the movement"
        blf.position(0, 70, yPos, 0)
        blf.draw(0, txtHelp5)
        yPos += (int(blf.dimensions(0, txtHelp4)[1]*2))
        blf.position(0 , 70, yPos, 0)
        blf.draw(0, txtHelp4)
        yPos += (int(blf.dimensions(0, txtHelp3)[1]*2))
        blf.position(0 , 70, yPos, 0)
        blf.draw(0, txtHelp3)
        yPos += (int(blf.dimensions(0, txtHelp2)[1]*2))
        blf.position(0 , 70, yPos, 0)
        blf.draw(0, txtHelp2)
        yPos += (int(blf.dimensions(0, txtHelp1)[1]*2))
        blf.position(0 , 70, yPos, 0)
        blf.draw(0, txtHelp1)

        # Draw edge
        bgl.glEnable(bgl.GL_BLEND)
        bgl.glColor4f(1.0, 0.1, 0.8, 1.0)
        bgl.glBegin(bgl.GL_LINES)
        for p in self.LinkedVertices1:
            bgl.glVertex2f(self.Vertex1.x2D, self.Vertex1.y2D)
            bgl.glVertex2f(p.x2D, p.y2D)
        for p in self.LinkedVertices2:
            bgl.glVertex2f(self.Vertex2.x2D, self.Vertex2.y2D)
            bgl.glVertex2f(p.x2D, p.y2D)
        bgl.glEnd()
コード例 #20
0
    def draw_index(rgb, index, coord):

        vector3d = matrix_world * coord
        x, y = loc3d2d(region, rv3d, vector3d)

        index = str(index)
        polyline = get_points(index)

        ''' draw polygon '''
        bgl.glColor4f(0, 0, 0, 0)
        bgl.glBegin(bgl.GL_POLYGON)
        for pointx, pointy in polyline:
            bgl.glVertex2f(pointx + x, pointy + y)
        bgl.glEnd()

        ''' draw text '''
        txt_width, txt_height = blf.dimensions(0, index)
        bgl.glColor3f(*rgb)
        blf.position(0, x - (txt_width / 2), y - (txt_height / 2), 0)
        blf.draw(0, index)
コード例 #21
0
def draw_points(context, points, size, gl_col):
    region = context.region
    rv3d = context.space_data.region_3d
    
    # needed for adjusting the size of gl_points    
    bgl.glEnable(bgl.GL_POINT_SMOOTH)
    bgl.glPointSize(size)
    bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
    
    bgl.glBegin(bgl.GL_POINTS)
    bgl.glColor4f(*gl_col)    
    for coord in points:
        vector3d = (coord.x, coord.y, coord.z)
        vector2d = loc3d2d(region, rv3d, vector3d)
        bgl.glVertex2f(*vector2d)
    bgl.glEnd()
    
    bgl.glDisable(bgl.GL_POINT_SMOOTH)
    bgl.glDisable(bgl.GL_POINTS)
    return
コード例 #22
0
def screen_v3d_batch_matrix_overlay(context, args):
    region = context.region
    region3d = context.space_data.region_3d
    cdat, alpha = args[0], args[1]
    if not alpha > 0.0:
        return

    pt = 0.5
    G = -0.001  # to z offset the plane from the axis
    coords = (-pt, pt, G), (pt, pt, G), (pt, -pt, G), (-pt, -pt, G)
    indices_plane = [(0, 1, 2), (0, 2, 3)]

    # first calculate positions and lerp colors
    coords_transformed = []
    indices_shifted = []
    idx_offset = 0
    colors = []
    for i, (matrix, color) in enumerate(cdat):
        r, g, b = color
        for x, y, z in coords:
            vector3d = matrix @ Vector((x, y, z))
            vector2d = loc3d2d(region, region3d, vector3d)
            coords_transformed.append(vector2d)
            colors.append((r, g, b, alpha))

        for indices in indices_plane:
            indices_shifted.append(tuple(idx + idx_offset for idx in indices))

        idx_offset += 4

    batch = batch_for_shader(smooth_2d_shader,
                             'TRIS', {
                                 "pos": coords_transformed,
                                 "color": colors
                             },
                             indices=indices_shifted)

    # smooth_2d_shader.bind()
    batch.draw(smooth_2d_shader)
コード例 #23
0
def draw_polyline_from_coordinates(context, points, LINE_TYPE):
    region = context.region
    rv3d = context.space_data.region_3d

    bgl.glColor4f(1.0, 1.0, 1.0, 1.0)

    if LINE_TYPE == "GL_LINE_STIPPLE":
        bgl.glLineStipple(4, 0x5555)
        bgl.glEnable(bgl.GL_LINE_STIPPLE)
        bgl.glColor4f(0.3, 0.3, 0.3, 1.0)
    
    bgl.glBegin(bgl.GL_LINE_STRIP)
    for coord in points:
        vector3d = (coord.x, coord.y, coord.z)
        vector2d = loc3d2d(region, rv3d, vector3d)
        bgl.glVertex2f(*vector2d)
    bgl.glEnd()
    
    if LINE_TYPE == "GL_LINE_STIPPLE":
        bgl.glDisable(bgl.GL_LINE_STIPPLE)
        bgl.glEnable(bgl.GL_BLEND)  # back to uninterupted lines
    
    return
コード例 #24
0
def draw_polyline_from_coordinates(context, points, LINE_TYPE):
    region = context.region
    rv3d = context.space_data.region_3d

    bgl.glColor4f(1.0, 1.0, 1.0, 1.0)

    if LINE_TYPE == "GL_LINE_STIPPLE":
        bgl.glLineStipple(4, 0x5555)
        bgl.glEnable(bgl.GL_LINE_STIPPLE)
        bgl.glColor4f(0.3, 0.3, 0.3, 1.0)

    bgl.glBegin(bgl.GL_LINE_STRIP)
    for coord in points:
        vector3d = (coord.x, coord.y, coord.z)
        vector2d = loc3d2d(region, rv3d, vector3d)
        bgl.glVertex2f(*vector2d)
    bgl.glEnd()

    if LINE_TYPE == "GL_LINE_STIPPLE":
        bgl.glDisable(bgl.GL_LINE_STIPPLE)
        bgl.glEnable(bgl.GL_BLEND)  # back to uninterupted lines

    return
コード例 #25
0
def draw_points(context, points, size, gl_col):
    region = context.region
    rv3d = context.space_data.region_3d
    
    this_object = context.active_object
    matrix_world = this_object.matrix_world  
    
    # needed for adjusting the size of gl_points    
    bgl.glEnable(bgl.GL_POINT_SMOOTH)
    bgl.glPointSize(size)
    bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
    
    bgl.glBegin(bgl.GL_POINTS)
    bgl.glColor4f(*gl_col)    
    for coord in points:
        # vector3d = matrix_world * (coord.x, coord.y, coord.z)
        vector3d = matrix_world * coord
        vector2d = loc3d2d(region, rv3d, vector3d)
        bgl.glVertex2f(*vector2d)
    bgl.glEnd()
    
    bgl.glDisable(bgl.GL_POINT_SMOOTH)
    bgl.glDisable(bgl.GL_POINTS)
    return
コード例 #26
0
ファイル: light_brush.py プロジェクト: JT-a/blenderpython279
    def modal(self, context, event):
        dist2d = lambda p1, p2: sqrt((p2[0] - p1[0])**2 + (p2[1] - p1[1])**2)
        
        if event.type in {'MOUSEMOVE'}:
            region = context.region  
            rv3d = context.space_data.region_3d
            
            self.mouseCoNew = (event.mouse_region_x, event.mouse_region_y, 0)
            #        
            loc2d = loc3d2d(region, rv3d, self.obLoc)
            dx = self.mouseCoNew[0] - self.mouseCo[0]
            dy = self.mouseCoNew[1] - self.mouseCo[1]
                        
            first_loc = Vector(self.first_value)
            last_loc = Vector((first_loc[0] + dx/(1000 if self.precision else 100), first_loc[1] + dy/(1000 if self.precision else 100), first_loc[2]))
            
            if self.axis == 2: #xy
                context.area.header_text_set("Move Dx: %.4f Dy: %.4f" % (dx, dy))
                last_loc[2] = self.backup_value[2]
            elif self.axis == 1: #y
                last_loc[0] = self.first_value[0]
                last_loc[2] = self.backup_value[2]
                context.area.header_text_set("Move: %.4f along local Y" % dy)
            elif self.axis == 0: #x
                last_loc[1] = self.first_value[1]
                last_loc[2] = self.backup_value[2]
                context.area.header_text_set("Move: %.4f along local X" % dx)
            
            last_loc[0] = (last_loc[0] + 2) % 4 - 2
            obj_ref['move'].location = last_loc
            self.tmp_value = last_loc
            
            return {'RUNNING_MODAL'}
        elif event.type == 'X' and event.value == 'PRESS':
            self.axis = 0 if self.axis != 0 else 2
        elif event.type == 'Y' and event.value == 'PRESS':
            self.axis = 1 if self.axis != 1 else 2
        elif event.type in {'LEFT_SHIFT', 'RIGHT_SHIFT'}:
             if event.value == 'PRESS':
                 self.precision = True
                 
                 tmp = self.first_value
                 self.first_value = self.tmp_value
                 self.tmp_value = tmp
                 
                 tmp = self.mouseCo
                 self.mouseCo = self.mouseCoNew
                 self.mouseCoNew = tmp
             elif event.value == 'RELEASE':
                 self.precision = False
                 
                 tmp = self.first_value
                 self.first_value = self.tmp_value
                 self.tmp_value = tmp
                 
                 tmp = self.mouseCo
                 self.mouseCo = self.mouseCoNew
                 self.mouseCoNew = tmp
        elif event.type == 'LEFTMOUSE':
            context.area.header_text_set()
            return {'FINISHED'}
        elif event.type in {'RIGHTMOUSE', 'ESC'}:
            obj_ref['move'].location = self.backup_value
            context.area.header_text_set()
            return {'CANCELLED'}
        else:
            #return {'PASS_THROUGH'}
            return {'RUNNING_MODAL'}

        return {'RUNNING_MODAL'}
コード例 #27
0
def draw_dimensions(region, rv3d, context, tetra_coords):

    apex, base1, base2, base3 = tetra_coords

    # TODO WARNING FACTORABLE CODE AHEAD
    # converting to screen coordinates
    screen_apex = loc3d2d(region, rv3d, apex)
    screen_base1 = loc3d2d(region, rv3d, base1)
    screen_base2 = loc3d2d(region, rv3d, base2)
    screen_base3 = loc3d2d(region, rv3d, base3)

    # DRAW X
    if base3.y > apex.y:
        YDIR = 1
    else:
        YDIR = -1
    # do we need to draw at all if there is no x distance?
    if base3.y != apex.y:
        y_dir = NUM_UNITS * YDIR
        base3_ext_y = Vector((base3.x, base3.y + y_dir, base3.z))
        base2_ext_y = Vector((base2.x, base2.y + y_dir, base2.z))
        scr_base3_ext_y = loc3d2d(region, rv3d, base3_ext_y)
        scr_base2_ext_y = loc3d2d(region, rv3d, base2_ext_y)

        bgl.glColor4f(0.203, 0.8, 1.0, 0.8)
        bgl.glBegin(bgl.GL_LINES)
        bgl.glVertex2f(*screen_base3)
        bgl.glVertex2f(*scr_base3_ext_y)
        bgl.glVertex2f(*screen_base2)
        bgl.glVertex2f(*scr_base2_ext_y)
        bgl.glEnd()

    # DRAW Y
    if base3.x > apex.x:
        XDIR = -1
    else:
        XDIR = 1
    # do we need to draw at all if there is no y distance?
    if base3.x != apex.x:
        x_dir = NUM_UNITS * XDIR
        base2_ext_x = Vector((base2.x + x_dir, base2.y, base2.z))
        base1_ext_x = Vector((base1.x + x_dir, base1.y, base1.z))
        scr_base2_ext_x = loc3d2d(region, rv3d, base2_ext_x)
        scr_base1_ext_x = loc3d2d(region, rv3d, base1_ext_x)

        bgl.glColor4f(0.203, 0.8, 1.0, 0.8)
        bgl.glBegin(bgl.GL_LINES)
        bgl.glVertex2f(*screen_base2)
        bgl.glVertex2f(*scr_base2_ext_x)
        bgl.glVertex2f(*screen_base1)
        bgl.glVertex2f(*scr_base1_ext_x)
        bgl.glEnd()

    # DRAW Z
    # check if there is a z distance
    if apex.z != base3.z:
        # draw z, use oposite y direction
        y_dir = NUM_UNITS * -YDIR
        apex_ext_y = Vector((apex.x, apex.y + y_dir, apex.z))
        base1_ext_y = Vector((base1.x, base1.y + y_dir, base1.z))
        scr_apex_ext_y = loc3d2d(region, rv3d, apex_ext_y)
        scr_base1_ext_y = loc3d2d(region, rv3d, base1_ext_y)

        bgl.glColor4f(0.203, 0.8, 1.0, 0.8)
        bgl.glBegin(bgl.GL_LINES)
        bgl.glVertex2f(*screen_apex)
        bgl.glVertex2f(*scr_apex_ext_y)
        bgl.glVertex2f(*screen_base1)
        bgl.glVertex2f(*scr_base1_ext_y)
        bgl.glEnd()

    # DRAW LINEAR
    # necessarily at the end because we know the y direction now.

    # X/Y angle (between base1, base3, base2)
    # find a cleaner (more clever) way to do
    if (apex.x > base3.x) and (apex.y > base3.y):
        vec1 = base1 - base3
        vec2 = base2 - base3
        XY_RAD = vec1.angle(vec2)  # -(pi*0.75)
    elif (apex.x > base3.x) and (apex.y < base3.y):
        vec1 = base2 - base1
        vec2 = base3 - base1
        XY_RAD = vec1.angle(vec2) + (1.5 * pi)
    elif (apex.y > base3.y) and (apex.x < base3.x):
        vec1 = base2 - base1
        vec2 = base3 - base1
        XY_RAD = vec1.angle(vec2) - (0.5 * pi)
    elif (apex.x < base3.x) and (apex.y < base3.y):
        vec1 = base2 - base1
        vec2 = base3 - base1
        XY_RAD = -vec1.angle(vec2) + (0.5 * pi)
    elif apex.y == base3.y:
        XY_RAD = pi
    elif apex.x == base3.x:
        XY_RAD = 0.5 * pi
    else:
        # dont bother drawing it.
        return

    # what a jungle.
    marker_xyz = Vector((0.0, NUM_UNITS * -YDIR, 0.0))
    myEul = Euler((0.0, 0.0, XY_RAD), 'XYZ')
    marker_xyz.rotate(myEul)  # rotate and modify vector in place.

    apex_ext_xyz = apex + marker_xyz
    base3_ext_xyz = base3 + marker_xyz

    scr_apex_ext_xyz = loc3d2d(region, rv3d, apex_ext_xyz)
    scr_base3_ext_xyz = loc3d2d(region, rv3d, base3_ext_xyz)

    bgl.glColor4f(0.203, 0.8, 1.0, 0.8)
    bgl.glBegin(bgl.GL_LINES)
    bgl.glVertex2f(*screen_base3)
    bgl.glVertex2f(*scr_base3_ext_xyz)
    bgl.glVertex2f(*screen_apex)
    bgl.glVertex2f(*scr_apex_ext_xyz)
    bgl.glEnd()

    #print("drawing dimensions next")
    return
コード例 #28
0
def draw_tris(region, rv3d, context):
    divs = 24  # verts per fan.
    n = 3  # ratio of shortest edge.

    def get_tri_coords(object_list):
        # replace for empties code.
        coordlist = [obj.location for obj in object_list]
        return coordlist

    def get_angle_rad(set_of_coords):
        coord1, coord2, coord3 = set_of_coords
        angle_rad = (coord1 - coord2).angle(coord3 - coord2)
        angle_deg = degrees(angle_rad)
        return angle_rad, angle_deg

    # if 3 empties selected
    coord1, coord2, coord3 = get_tri_coords(context.selected_objects)

    # measure angle between
    angle1 = [coord3, coord1, coord2]
    angle2 = [coord1, coord2, coord3]
    angle3 = [coord2, coord3, coord1]

    edge1 = (coord1 - coord2).length
    edge2 = (coord2 - coord3).length
    edge3 = (coord3 - coord1).length
    shortest_edge = min(edge1, edge2, edge3)
    radial_d = shortest_edge / n

    def make_fan_poly_from_edges(angle_object, radius):
        coordinate_1, shared_co, coordinate_2 = angle_object

        # get length of edge, lerp it , place a point at radial distance (pointN)
        len1 = (coordinate_1 - shared_co).length
        len2 = (coordinate_2 - shared_co).length
        tlerp1 = 1 / (len1 / radius)
        tlerp2 = 1 / (len2 / radius)
        point1 = shared_co.lerp(coordinate_1, tlerp1)
        point2 = shared_co.lerp(coordinate_2, tlerp2)

        # place imaginary line between (point1, point2)
        radial_collection = []
        radial_collection.append(shared_co)

        # start from point1, place temp point (1/24)*i
        # collect points. check all points for distance to angle_point.
        rate = 1 / divs
        for notch in range(divs + 1):
            new_vec = point1.lerp(point2, rate * notch)
            # move new vec away from shared point until the distance is radius.
            new_vec_len = (new_vec - shared_co).length
            lerp_distance = radius / new_vec_len
            radial_point = shared_co.lerp(new_vec, lerp_distance)
            radial_collection.append(radial_point)

        radial_collection.append(shared_co)

        # make polygon
        return radial_collection

    bgl.glEnable(bgl.GL_BLEND)  # enable blending
    bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)

    angle_list = [angle1, angle2, angle3]
    for item in angle_list:
        polyline = make_fan_poly_from_edges(item, radial_d)

        #can be modified per polyline
        bgl.glColor4f(0.103, 0.3, 0.6, 0.4)

        bgl.glBegin(bgl.GL_POLYGON)
        for segment in polyline:
            scr_pixel = loc3d2d(region, rv3d, segment)
            bgl.glVertex2f(*scr_pixel)

        bgl.glEnd()

    # get text.
    for item in angle_list:

        bgl.glColor4f(0.83, 0.8, 0.9, 0.7)
        angrad, angdeg = get_angle_rad(item)
        polyline = make_fan_poly_from_edges(item, radial_d)

        # find coordinate to place the text
        cpoint1 = polyline[0]
        midpoint = floor(len(polyline) / 2)
        cpoint2 = polyline[midpoint]
        cmidway = cpoint1.lerp(cpoint2, 0.5)
        scr_coord = loc3d2d(region, rv3d, cmidway)

        # round both text
        angrad_round = round(angrad, ANG_ROUND)
        angdeg_round = round(angdeg, DEG_ROUND)
        str_angrad = str(angrad_round)
        str_angdeg = str(angdeg_round)
        combined_string = str_angrad + " , " + str_angdeg

        # get length of text, place text .5 of length to the left of the coord.
        font_id = 0
        blf.size(font_id, 12, 72)

        text_width, text_height = blf.dimensions(font_id, combined_string)
        x_pos = text_width / 2

        blf.position(font_id, scr_coord[0] - x_pos, scr_coord[1], 0)
        blf.draw(font_id, combined_string)

    return
コード例 #29
0
    def modal(self, context, event):
        if event.type == 'MOUSEMOVE':
            Vertices = self.bm.verts
            # Calculate the temp t value. Stored in td
            tmpMouse = Vector((event.mouse_x, event.mouse_y))
            t_diff = (tmpMouse - self.tmpMouse).length
            self.tmpMouse = tmpMouse
            if self.Vertex2.original.idx is not None: # 2 vertex selected
                td = t_diff * self.Direction / self.ScreenDistance(self.Vertex1.original.co,
                                                                   self.Vertex2.original.co)
            else:  # 1 vertex selected
                td = t_diff * self.Direction / self.ScreenDistance(self.Vertex1.original.co,
                                                                   self.LinkedVertices1[self.VertLinkedIdx].original.co)
            if event.mouse_x < self.tmpMouse_x:
                td = -td

            if self.Vertex2.original.idx is not None: # 2 vertex selected
                # Calculate the t valuse
                if self.FirstVertexMove:
                    self.Vertex1.t = self.Vertex1.t + td
                else:
                    self.Vertex2.t = self.Vertex2.t + td
                # Move the vertex
                Vertices[self.Vertex1.original.idx].co = NewCoordinate(self.Vertex1.original.co,
                                                                       self.Vertex2.original.co,
                                                                       self.Vertex1.t)
                Vertices[self.Vertex2.original.idx].co = NewCoordinate(self.Vertex2.original.co,
                                                                       self.Vertex1.original.co,
                                                                       self.Vertex2.t)
            else:  # 1 vertex selected
                if self.LeftAltPress:  # Continuous slide
                    # Calculate the t valuse
                    self.Vertex2.t = self.Vertex2.t + td
                    # Move the vertex
                    Vertices[self.Vertex1.original.idx].co = NewCoordinate(self.Vertex2.original.co,
                                                                           self.LinkedVertices1[self.VertLinkedIdx].original.co,
                                                                           self.Vertex2.t)
                else:
                    # Calculate the t valuse
                    self.LinkedVertices1[self.VertLinkedIdx].t = self.LinkedVertices1[self.VertLinkedIdx].t + td
                    # Move the vertex
                    Vertices[self.Vertex1.original.idx].co = NewCoordinate(self.Vertex1.original.co,
                                                                           self.LinkedVertices1[self.VertLinkedIdx].original.co,
                                                                           self.LinkedVertices1[self.VertLinkedIdx].t)
                self.ActiveVertex = self.Vertex1.original.idx
            self.tmpMouse_x = event.mouse_x
            context.area.tag_redraw()

        elif event.type == 'LEFT_SHIFT':  # Hold left SHIFT for precision
            self.LeftShiftPress = not self.LeftShiftPress
            if self.LeftShiftPress:
                self.Direction *= 0.1
            else:
                if self.Direction < 0:
                    self.Direction = -1
                else:
                    self.Direction = 1

        elif event.type == 'LEFT_ALT':  # Hold ALT to use continuous slide
            self.LeftAltPress = not self.LeftAltPress
            if self.LeftAltPress and self.Vertex2.original.idx is None:
                vert = self.bm.verts[self.Vertex1.original.idx]
                self.Vertex2.original.co = Vector((vert.co.x, vert.co.y, vert.co.z))
                self.Vertex2.t = 0

        elif event.type == 'LEFT_ARROW':  # Reverse direction
            if self.Direction < 0.0:
                self.Direction = - self.Direction

        elif event.type == 'RIGHT_ARROW':  # Restore direction
            if self.Direction > 0.0:
                self.Direction = - self.Direction

        elif event.type == 'WHEELDOWNMOUSE':  # Change the vertex to be moved
            if self.Vertex2.original.idx is None:
                if self.LeftAltPress:
                    vert=self.bm.verts[self.Vertex1.original.idx]
                    self.Vertex2.original.co = Vector((vert.co.x, vert.co.y, vert.co.z))
                    self.Vertex2.t = 0
                self.VertLinkedIdx = self.VertLinkedIdx + 1
                if self.VertLinkedIdx > len(self.LinkedVertices1) - 1:
                    self.VertLinkedIdx = 0
                bpy.ops.mesh.select_all(action='DESELECT')
                self.bm.verts[self.Vertex1.original.idx].select = True
                self.bm.verts[self.LinkedVertices1[self.VertLinkedIdx].original.idx].select = True
            else:
                self.FirstVertexMove = not self.FirstVertexMove
                if self.LeftAltPress == False:
                    self.Vertex1.t = 0
                    self.Vertex2.t = 0
                if self.FirstVertexMove:
                    self.ActiveVertex = self.Vertex1.original.idx
                else:
                    self.ActiveVertex = self.Vertex2.original.idx
            # Keep Vertex movement coherent with Mouse movement
            if self.Vertex2.original.idx is not None:
                if self.FirstVertexMove: 
                    tmpX1, tmpY1 = loc3d2d(context.region, context.space_data.region_3d, self.Vertex1.original.co)
                    tmpX2, tmpY2 = loc3d2d(context.region, context.space_data.region_3d, self.Vertex2.original.co)
                    if ((tmpX1 > tmpX2 and self.Direction >= 0) or (tmpX2 > tmpX1 and self.Direction >= 0)):
                        self.Direction = -self.Direction
                else:
                    tmpX1, tmpY1 = loc3d2d(context.region, context.space_data.region_3d, self.Vertex2.original.co)
                    tmpX2, tmpY2 = loc3d2d(context.region, context.space_data.region_3d, self.Vertex1.original.co)
                    if (tmpX1 < tmpX2 and self.Direction < 0) or (tmpX2 < tmpX1 and self.Direction >= 0):
                        self.Direction = -self.Direction
            else:
                tmpX1, tmpY1 = loc3d2d(context.region, context.space_data.region_3d, self.Vertex1.original.co)
                tmpX2, tmpY2 = loc3d2d(context.region, context.space_data.region_3d, self.LinkedVertices1[self.VertLinkedIdx].original.co)
                if ((tmpX1 > tmpX2 and self.Direction >= 0) or (tmpX2 > tmpX1 and self.Direction < 0)):
                    self.Direction = -self.Direction
            context.area.tag_redraw()

        elif event.type == 'WHEELUPMOUSE':  # Change the vertex to be moved
            if self.Vertex2.original.idx is None:
                if self.LeftAltPress:
                    vert = self.bm.verts[self.Vertex1.original.idx]
                    self.Vertex2.original.co = Vector((vert.co.x, vert.co.y, vert.co.z))
                    self.Vertex2.t = 0
                self.VertLinkedIdx = self.VertLinkedIdx - 1
                if self.VertLinkedIdx < 0:
                    self.VertLinkedIdx = len(self.LinkedVertices1) - 1
                bpy.ops.mesh.select_all(action='DESELECT')
                self.bm.verts[self.Vertex1.original.idx].select = True
                self.bm.verts[self.LinkedVertices1[self.VertLinkedIdx].original.idx].select = True
            else:
                self.FirstVertexMove = not self.FirstVertexMove
                if self.LeftAltPress == False:
                    self.Vertex1.t = 0
                    self.Vertex2.t = 0
                if self.FirstVertexMove:
                    self.ActiveVertex = self.Vertex1.original.idx
                else:
                    self.ActiveVertex = self.Vertex2.original.idx
            # Keep Vertex movement coherent with Mouse movement
            if self.Vertex2.original.idx is not None:
                if self.FirstVertexMove: 
                    tmpX1, tmpY1 = loc3d2d(context.region, context.space_data.region_3d, self.Vertex1.original.co)
                    tmpX2, tmpY2 = loc3d2d(context.region, context.space_data.region_3d, self.Vertex2.original.co)
                    if ((tmpX1 > tmpX2 and self.Direction >= 0) or (tmpX2 > tmpX1 and self.Direction >= 0)):
                        self.Direction = -self.Direction
                else:
                    tmpX1, tmpY1 = loc3d2d(context.region, context.space_data.region_3d, self.Vertex2.original.co)
                    tmpX2, tmpY2 = loc3d2d(context.region, context.space_data.region_3d, self.Vertex1.original.co)
                    if (tmpX1 < tmpX2 and self.Direction < 0) or (tmpX2 < tmpX1 and self.Direction >= 0):
                        self.Direction = -self.Direction
            else:
                tmpX1, tmpY1 = loc3d2d(context.region, context.space_data.region_3d, self.Vertex1.original.co)
                tmpX2, tmpY2 = loc3d2d(context.region, context.space_data.region_3d, self.LinkedVertices1[self.VertLinkedIdx].original.co)
                if ((tmpX1 > tmpX2 and self.Direction >= 0) or (tmpX2 > tmpX1 and self.Direction < 0)):
                    self.Direction = -self.Direction
            context.area.tag_redraw()

        elif event.type == 'LEFTMOUSE':  # Confirm and exit
            Vertices = self.bm.verts
            bpy.ops.mesh.select_all(action='DESELECT')
            Vertices[self.Vertex1.original.idx].select = True
            if self.Vertex2.original.idx is not None:
                Vertices[self.Vertex2.original.idx].select = True
            context.region.callback_remove(self._handle)
            context.area.tag_redraw()
            return {'FINISHED'}

        elif event.type in {'RIGHTMOUSE', 'ESC'}:  # Restore and exit
            Vertices = self.bm.verts
            bpy.ops.mesh.select_all(action='DESELECT')
            Vertices[self.Vertex1.original.idx].co = self.Vertex1.original.co
            Vertices[self.Vertex1.original.idx].select = True
            if self.Vertex2.original.idx is not None:
                Vertices[self.Vertex2.original.idx].co = self.Vertex2.original.co
                Vertices[self.Vertex2.original.idx].select = True
            context.region.callback_remove(self._handle)
            context.area.tag_redraw()
            return {'CANCELLED'}

        return {'RUNNING_MODAL'}
コード例 #30
0
    def invoke(self, context, event):
        if context.active_object == None or context.active_object.type != "MESH":
            self.report({'WARNING'}, "Not any active object or not an mesh object:")
            return {'CANCELLED'}

        if context.active_object.mode != 'EDIT':
            self.report({'WARNING'}, "Mesh isn't in Edit Mode")
            return {'CANCELLED'}
        
        self.obj = bpy.context.object
        self.mesh = self.obj.data
        self.bm = bmesh.from_edit_mesh(self.mesh)

        Count=0
        Selected=False
        SelectedVertices = []  # Index of selected vertices
        for i, v in enumerate(self.bm.verts):
            if v.select and v.is_valid:
                SelectedVertices.append(v.index)
                Selected = True
                Count += 1 
                if (Count > 2):  # More than 2 vertices selected
                    Selected = False
                    break

        if Selected == False:
            self.report({'WARNING'}, "0 or more then 2 vertices selected, could not start")
            return {'CANCELLED'}

        self.tmpMouse[0], self.tmpMouse[1] = (event.mouse_x, event.mouse_y)
        self.tmpMouse_x = self.tmpMouse[0]

        self.Vertex1 = Point()
        self.Vertex2 = Point()
        self.LinkedVertices1 = []
        self.LinkedVertices2 = []

        # Store selected vertices data. To move in the first Loop
        self.Vertex1.original.idx = SelectedVertices[0]
        self.Vertex1.original.co = self.bm.verts[SelectedVertices[0]].co.copy()
        self.Vertex1.new = self.Vertex1.original
        x, y = loc3d2d(context.region, context.space_data.region_3d, self.bm.verts[SelectedVertices[0]].co)  # For draw edge
        self.Vertex1.x2D = x
        self.Vertex1.y2D = y
        if len(SelectedVertices) == 2:
            self.Vertex2.original.idx = SelectedVertices[1]
            self.Vertex2.original.co = self.bm.verts[SelectedVertices[1]].co.copy()
            self.Vertex2.new = self.Vertex2.original
            x, y = loc3d2d(context.region, context.space_data.region_3d, self.bm.verts[SelectedVertices[1]].co)  # For draw edge
            self.Vertex2.x2D = x
            self.Vertex2.y2D = y

        if len(SelectedVertices) == 2:
            self.bm.verts[self.Vertex2.original.idx].select = False  # Unselect the second selected vertex

        # Store linked vertices data, except the selected vertices
        for i, vert in enumerate(self.bm.verts[self.Vertex1.original.idx].link_edges):
            self.LinkedVertices1.append(Point())
            self.LinkedVertices1[-1].original.idx = vert.other_vert(self.bm.verts[self.Vertex1.original.idx]).index   #e_0.other_vert(v_0).index
            self.LinkedVertices1[-1].original.co = vert.other_vert(self.bm.verts[self.Vertex1.original.idx]).co.copy()
            self.LinkedVertices1[-1].new = self.LinkedVertices1[-1].original
            x, y = loc3d2d(context.region, context.space_data.region_3d, vert.other_vert(self.bm.verts[self.Vertex1.original.idx]).co)  # For draw edge
            self.LinkedVertices1[-1].x2D = x
            self.LinkedVertices1[-1].y2D = y
        if len(SelectedVertices) == 2:
            for i, vert in enumerate(self.bm.verts[self.Vertex2.original.idx].link_edges):
                self.LinkedVertices2.append(Point())
                self.LinkedVertices2[-1].original.idx = vert.other_vert(self.bm.verts[self.Vertex2.original.idx]).index
                self.LinkedVertices2[-1].original.co = vert.other_vert(self.bm.verts[self.Vertex2.original.idx]).co.copy()
                self.LinkedVertices2[-1].new = self.LinkedVertices1[-1].original
                x, y = loc3d2d(context.region, context.space_data.region_3d, vert.other_vert(self.bm.verts[self.Vertex2.original.idx]).co)  # For draw edge
                self.LinkedVertices2[-1].x2D = x
                self.LinkedVertices2[-1].y2D = y

        # Check for no linked vertex. Can be happen also with a mix of Select Mode
        # Need only with 1 vertex selected
        if len(SelectedVertices) == 1 and len(self.LinkedVertices1) == 0:
            self.report({'WARNING'}, "Isolated vertex or mixed Select Mode!")
            return {'CANCELLED'}
        # Check for duplicate vertices. If some linked vertice have the same coords of selected vertice
        # we have the error "division by 0
        if self.Vertex1.original.co == self.Vertex2.original.co:
            self.report({'WARNING'}, "At least one duplicate vertex")
            return {'CANCELLED'}
            
        self.bm.verts[self.Vertex1.original.idx].select = True  # Select the first selected vertex
        if len(SelectedVertices) == 2:
            self.bm.verts[self.Vertex2.original.idx].select = True  # Select the second selected vertex
        else:
            self.bm.verts[self.LinkedVertices1[0].original.idx].select = True  # Select the first linked vertex
        self.ActiveVertex = self.Vertex1.original.idx

        # Keep Vertex movement coherent with Mouse movement
        tmpX1, tmpY1 = loc3d2d(context.region, context.space_data.region_3d, self.Vertex1.original.co)
        if len(SelectedVertices) == 2:
            tmpX2, tmpY2 = loc3d2d(context.region, context.space_data.region_3d, self.Vertex2.original.co)
        else:
            tmpX2, tmpY2 = loc3d2d(context.region, context.space_data.region_3d, self.LinkedVertices1[0].original.co)
        if tmpX2 - tmpX1 < 0:
            self.Direction = -self.Direction

        context.area.tag_redraw()  # Force the redraw of the 3D View

        # Add the region OpenGL drawing callback
        # draw in view space with 'POST_VIEW' and 'PRE_VIEW'
        self._handle = context.region.callback_add(self.__class__.draw_callback_px, (self, context), 'POST_PIXEL')
        context.window_manager.modal_handler_add(self)
        return {'RUNNING_MODAL'}
コード例 #31
0
def draw_dimensions(region, rv3d, context, tetra_coords):
    
    
    apex, base1, base2, base3 = tetra_coords

    # TODO WARNING FACTORABLE CODE AHEAD
    # converting to screen coordinates
    screen_apex = loc3d2d(region, rv3d, apex)
    screen_base1 = loc3d2d(region, rv3d, base1) 
    screen_base2 = loc3d2d(region, rv3d, base2)
    screen_base3 = loc3d2d(region, rv3d, base3)
    # another 8.
    # [x] 1 scr_base3_ext_y
    # [x] 2 scr_base2_ext_y
    # [x] 3 scr_base2_ext_x
    # [x] 4 scr_base1_ext_x
    # [x] 5 scr_apex_ext_y
    # [x] 6 scr_base1_ext_y
    # [x] 7 scr_liner_top
    # [x] 8 scr_liner_bottom

    
    # DRAW X  
    if base3.y > apex.y:
        YDIR = 1 
    else:
        YDIR = -1 
    # do we need to draw at all if there is no x distance?        
    if base3.y != apex.y:
        y_dir = NUM_UNITS * YDIR
        base3_ext_y = Vector((base3.x, base3.y+y_dir, base3.z))
        base2_ext_y = Vector((base2.x, base2.y+y_dir, base2.z))
        scr_base3_ext_y = loc3d2d(region, rv3d, base3_ext_y)
        scr_base2_ext_y = loc3d2d(region, rv3d, base2_ext_y)
        
        bgl.glColor4f(0.203, 0.8, 1.0, 0.8)
        bgl.glBegin(bgl.GL_LINES)
        bgl.glVertex2f(*screen_base3)  
        bgl.glVertex2f(*scr_base3_ext_y)  
        bgl.glVertex2f(*screen_base2)  
        bgl.glVertex2f(*scr_base2_ext_y)  
        bgl.glEnd()

    # DRAW Y
    if base3.x > apex.x:
        XDIR = -1 
    else:
        XDIR = 1 
    # do we need to draw at all if there is no y distance?        
    if base3.x != apex.x:    
        x_dir = NUM_UNITS * XDIR
        base2_ext_x = Vector((base2.x+x_dir, base2.y, base2.z))
        base1_ext_x = Vector((base1.x+x_dir, base1.y, base1.z))
        scr_base2_ext_x = loc3d2d(region, rv3d, base2_ext_x)
        scr_base1_ext_x = loc3d2d(region, rv3d, base1_ext_x)
        
        bgl.glColor4f(0.203, 0.8, 1.0, 0.8)
        bgl.glBegin(bgl.GL_LINES)
        bgl.glVertex2f(*screen_base2)  
        bgl.glVertex2f(*scr_base2_ext_x)  
        bgl.glVertex2f(*screen_base1)  
        bgl.glVertex2f(*scr_base1_ext_x)  
        bgl.glEnd()
 
    # DRAW Z 
    # check if there is a z distance
    if apex.z != base3.z:
        # draw z, use oposite y direction
        y_dir = NUM_UNITS * -YDIR
        apex_ext_y = Vector((apex.x, apex.y+y_dir, apex.z))
        base1_ext_y = Vector((base1.x, base1.y+y_dir, base1.z))
        scr_apex_ext_y = loc3d2d(region, rv3d, apex_ext_y)
        scr_base1_ext_y = loc3d2d(region, rv3d, base1_ext_y)
        
        bgl.glColor4f(0.203, 0.8, 1.0, 0.8)
        bgl.glBegin(bgl.GL_LINES)
        bgl.glVertex2f(*screen_apex)  
        bgl.glVertex2f(*scr_apex_ext_y)  
        bgl.glVertex2f(*screen_base1)  
        bgl.glVertex2f(*scr_base1_ext_y)  
        bgl.glEnd()

    

    # DRAW LINEAR
    # necessarily at the end because we know the y direction now.
    
    # X/Y angle (between base1, base3, base2)
    # find a cleaner (more clever) way to do 
    if (apex.x > base3.x) and (apex.y > base3.y):
        vec1 = base1-base3
        vec2 = base2-base3
        XY_RAD = vec1.angle(vec2) # -(pi*0.75)    
    elif (apex.x > base3.x) and (apex.y < base3.y):
        vec1 = base2-base1
        vec2 = base3-base1
        XY_RAD = vec1.angle(vec2)+(1.5*pi)    
    elif (apex.y > base3.y) and (apex.x < base3.x):
        vec1 = base2-base1
        vec2 = base3-base1
        XY_RAD = vec1.angle(vec2)-(0.5*pi)    
    elif (apex.x < base3.x) and (apex.y < base3.y):
        vec1 = base2-base1
        vec2 = base3-base1
        XY_RAD = -vec1.angle(vec2) +(0.5*pi)
    elif apex.y == base3.y:
        XY_RAD = pi
    elif apex.x == base3.x:
        XY_RAD = 0.5*pi
    else: 
        # dont bother drawing it.
        return
    

    # what a jungle.
    marker_xyz = Vector((0.0, NUM_UNITS*-YDIR, 0.0))
    myEul = Euler((0.0, 0.0, XY_RAD), 'XYZ')
    marker_xyz.rotate(myEul)    # rotate and modify vector in place.
    
    apex_ext_xyz = apex + marker_xyz
    base3_ext_xyz = base3 + marker_xyz
    
    scr_apex_ext_xyz = loc3d2d(region, rv3d, apex_ext_xyz)
    scr_base3_ext_xyz = loc3d2d(region, rv3d, base3_ext_xyz)
    
    bgl.glColor4f(0.203, 0.8, 1.0, 0.8)
    bgl.glBegin(bgl.GL_LINES)
    bgl.glVertex2f(*screen_base3)  
    bgl.glVertex2f(*scr_base3_ext_xyz)  
    bgl.glVertex2f(*screen_apex)  
    bgl.glVertex2f(*scr_apex_ext_xyz)  
    bgl.glEnd()
        
    #print("drawing dimensions next")
    return
コード例 #32
0
def draw_tris(region, rv3d, context):
    divs = 24   # verts per fan.
    n = 3       # ratio of shortest edge.

    def get_tri_coords(object_list):
        # replace for empties code.
        coordlist = [obj.location for obj in object_list]
        return coordlist
    
    def get_angle_rad(set_of_coords):
        # angle1_rad = (coord3-coord1).angle(coord2-coord1)
        # angle2_rad = (coord1-coord2).angle(coord3-coord2)
        # angle3_rad = (coord2-coord3).angle(coord1-coord3)
        # angle1_deg = degrees(angle1_rad)
        # angle2_deg = degrees(angle2_rad)
        # angle3_deg = degrees(angle3_rad)
        coord1, coord2, coord3 = set_of_coords
        angle_rad = (coord1-coord2).angle(coord3-coord2)
        angle_deg = degrees(angle_rad)
        return angle_rad, angle_deg
    
    
    # if 3 empties selected
    coord1, coord2, coord3 = get_tri_coords(context.selected_objects)
    
    # measure angle between 
    angle1 = [coord3, coord1, coord2]
    angle2 = [coord1, coord2, coord3]
    angle3 = [coord2, coord3, coord1]
        
    edge1 = (coord1-coord2).length
    edge2 = (coord2-coord3).length
    edge3 = (coord3-coord1).length
    shortest_edge = min(edge1, edge2, edge3)
    radial_d = shortest_edge / n
    
    
    
    def make_fan_poly_from_edges(angle_object, radius):
        coordinate_1, shared_co, coordinate_2 = angle_object
    
        # get length of edge, lerp it , place a point at radial distance (pointN)
        len1 = (coordinate_1-shared_co).length
        len2 = (coordinate_2-shared_co).length
        tlerp1 = 1/(len1/radius)
        tlerp2 = 1/(len2/radius)
        point1 = shared_co.lerp(coordinate_1, tlerp1)
        point2 = shared_co.lerp(coordinate_2, tlerp2)
                
        # place imaginary line between (point1, point2)
        radial_collection = []
        radial_collection.append(shared_co)
      
        # start from point1, place temp point (1/24)*i   
        # collect points. check all points for distance to angle_point.
        rate = 1/divs
        for notch in range(divs+1):
            new_vec = point1.lerp(point2, rate*notch)
            # move new vec away from shared point until the distance is radius.
            new_vec_len = (new_vec-shared_co).length
            lerp_distance = radius/new_vec_len
            radial_point = shared_co.lerp(new_vec, lerp_distance)
            radial_collection.append(radial_point)
        
        radial_collection.append(shared_co)
              
        # make polygon 
        return radial_collection
       
    
    bgl.glEnable(bgl.GL_BLEND) # enable blending
    bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
    
    angle_list = [angle1, angle2, angle3]
    for item in angle_list:
        polyline = make_fan_poly_from_edges(item, radial_d)
    
        #can be modified per polyline    
        bgl.glColor4f(0.103, 0.3, 0.6, 0.4)    
    
        bgl.glBegin(bgl.GL_POLYGON)    
        for segment in polyline:
            scr_pixel = loc3d2d(region, rv3d, segment)
            bgl.glVertex2f(*scr_pixel)  
    
        bgl.glEnd()
        

    # get text.        
    for item in angle_list:    

        bgl.glColor4f(0.83, 0.8, 0.9, 0.7)    
        angrad, angdeg = get_angle_rad(item)
        polyline = make_fan_poly_from_edges(item, radial_d)

        # find coordinate to place the text
        cpoint1 = polyline[0]
        midpoint = floor(len(polyline)/2)
        cpoint2 = polyline[midpoint]
        cmidway = cpoint1.lerp(cpoint2, 0.5)
        scr_coord = loc3d2d(region, rv3d, cmidway)
        
        # round both text
        angrad_round = round(angrad, ANG_ROUND)
        angdeg_round = round(angdeg, DEG_ROUND)
        str_angrad = str(angrad_round)
        str_angdeg = str(angdeg_round)
        combined_string = str_angrad + " , " + str_angdeg
        
        
        # get length of text, place text .5 of length to the left of the coord.
        font_id = 0
        blf.size(font_id, 12, 72)  
        
        text_width, text_height = blf.dimensions(font_id, combined_string)
        x_pos = text_width/2

        blf.position(font_id, scr_coord[0]-x_pos, scr_coord[1], 0)
        blf.draw(font_id, combined_string)
        
    return