Exemple #1
0
def subdivide_face_to_quads(pts, pol, verts_m, random_f):
    faces_p = []
    new_face = faces_p.append

    r_t = 0
    v_c_x = 0
    v_c_y = 0
    v_c_z = 0
    len_p = len(pts)
    f_index= len(verts_m)
    for i in range(len_p):
        f = 0.5
        new_p = lerp(pts[i], pts[(i+1) % len_p], f)
        verts_m.extend([new_p])
        f_c = 0.5 +(random.random() - 0.5) * random_f
        r_t += f_c
        v_c_x += pts[i][0] * f_c
        v_c_y += pts[i][1] * f_c
        v_c_z += pts[i][2] * f_c
        new_face([
            pol[i],
            f_index+i,
            f_index + len_p,
            f_index + (i + len_p - 1) % (len_p) ])

    v_c_x /= r_t
    v_c_y /= r_t
    v_c_z /= r_t

    verts_m.extend([[v_c_x, v_c_y, v_c_z]])

    return faces_p
Exemple #2
0
def random_subdiv_mesh(verts_m, pols_m, iteration):

    verts, faces = [], []
    for pol in pols_m:
        verts_out, faces_out = [], []
        new_quad = faces_out.append

        pts = sort(verts_m, pol)
        X = 0.5 + (random.random() - 0.5) * random_factor
        Y = 0.5 + (random.random() - 0.5) * random_factor
        pos_a = lerp(pts[0], pts[1], Y)
        pos_b = lerp(pts[1], pts[2], X)
        pos_c = lerp(pts[3], pts[2], 1 - Y)
        pos_d = lerp(pts[0], pts[3], X)
        pos_e = lerp(pos_d, pos_b, Y)
        pos_f = lerp(pos_d, pos_b, 1 - Y)

        # indices = 0, 1, 2, 3
        verts_out.extend(pts)

        # indices =       4,     5,     6,     7,     8,     9
        verts_out.extend([pos_a, pos_b, pos_c, pos_d, pos_e, pos_f])

        new_quad([0, 4, 8, 7])
        new_quad([4, 1, 5, 8])
        new_quad([5, 2, 6, 9])
        new_quad([7, 9, 6, 3])
        faces.append(faces_out)
        verts.append(verts_out)

    verts, _, faces = mesh_join(verts, [], faces)
    if iteration < 2:
        return verts, faces
    else:
        return random_subdiv_mesh(verts, faces, iteration - 1)
def random_subdiv_mesh(verts_m, pols_m, iteration, field):

    verts, faces = [], []
    for pol in pols_m:
        verts_out, faces_out = [], []
        new_quad = faces_out.append
        pts = sort(verts_m, pol)
        print(field.evaluate(*get_center(pts)))
        if field.evaluate(*get_center(pts)) > subdiv_threshold:
        #if random.random()>subdiv_probability:
            
            X = 0.5 +(random.random() - 0.5) * random_factor
            Y = 0.5 +(random.random() - 0.5) * random_factor
            pos_a = lerp(pts[0], pts[1], Y)
            pos_b = lerp(pts[1], pts[2], X)
            pos_c = lerp(pts[3], pts[2], 1-Y)
            pos_d = lerp(pts[0], pts[3], X)
            pos_e = lerp(pos_d, pos_b, Y)
            pos_f = lerp(pos_d, pos_b, 1-Y)

            # indices = 0, 1, 2, 3
            verts_out.extend(pts)

            # indices =       4,     5,     6,     7,     8,     9
            verts_out.extend([pos_a, pos_b, pos_c, pos_d, pos_e, pos_f])

            new_quad([0, 4, 8, 7])
            new_quad([4, 1, 5, 8])
            new_quad([5, 2, 6, 9])
            new_quad([7, 9, 6, 3])
            
        else:
            verts_out.extend(pts)
            new_quad([0, 1, 2, 3])
        faces.append(faces_out)
        verts.append(verts_out)

    verts, _, faces = mesh_join(verts, [], faces)
    if iteration < 2:
        return verts, faces
    else:
        return random_subdiv_mesh(verts, faces, iteration - 1, field)