space_view3d_paint_bprojection.py

bl_info = {
    "name": "BProjection",
    "description": "Help Clone tool",
    "author": "kgeogeo",
    "version": (2, 0, 1),
    "blender": (2, 77, 3),
    "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts/3D_interaction/bprojection",
    "tracker_url": "https://developer.blender.org/maniphest/task/edit/form/2/",
    "category": "Paint"}

import bpy
from bpy.app.handlers import persistent
from bpy.types import (
            Panel,
            Operator,
            PropertyGroup,
            AddonPreferences,
            )
from bpy.props import (
            IntProperty,
            FloatProperty,
            BoolProperty,
            StringProperty,
            FloatVectorProperty,
            CollectionProperty,
           )
from bpy_extras import view3d_utils

from math import (
            radians,
            sqrt,
            pi,
            )

from mathutils import (
            Quaternion,
            Vector,
            )

BProjection_Empty = 'Empty for BProjection'
BProjection_Material = 'Material for BProjection'
BProjection_Texture = 'Texture for BProjection'


# Main function for align the plan to view
def align_to_view(context):
    global last_mouse
    last_mouse = Vector((0, 0))
    ob = context.object
    em = bpy.data.objects[BProjection_Empty]
    rotation = em.custom_rotation
    scale = em.custom_scale
    z = em.custom_location.z
    pos = [em.custom_location.x, em.custom_location.y]

    sd = context.space_data
    r3d = sd.region_3d
    r3d.update()
    vr = r3d.view_rotation
    quat = Quaternion((0.0, 0.0, 1.0), radians(float(rotation)))
    v = Vector((pos[0], pos[1], z))
    v.rotate(vr)

    em = bpy.data.objects[BProjection_Empty]
    img = bpy.data.textures[BProjection_Texture].image

    if img and img.size[1] != 0:
        prop = img.size[0] / img.size[1]
    else:
        prop = 1

    if em.custom_linkscale:
        em.scale = Vector((prop * scale[0], scale[0], 1))
    else:
        em.scale = Vector((prop * scale[0], scale[1], 1))
    pos_cur = em.location - sd.cursor_location
    rot_cur1 = em.rotation_euler.to_quaternion()
    em.location = v + ob.location
    em.rotation_euler = Quaternion.to_euler(vr * quat)
    if em.custom_c3d:
        if em.custom_old_scale != em.custom_scale:
            pos_cur = em.location - sd.cursor_location
        rot_cur2 = em.rotation_euler.to_quaternion()
        rot_cur1.invert()
        pos_cur.rotate(rot_cur1)
        pos_cur.rotate(rot_cur2)
        v = em.location - pos_cur
        sd.cursor_location = v


def applyimage(context):
    img = bpy.data.textures[BProjection_Texture].image
    ob = context.object

    face = ob.data.polygons
    uvdata = ob.data.uv_textures.active.data

    for f, d in zip(face, uvdata):
        if f.select:
            d.image = img

    align_to_view(context)
    ob.data.update()


# Function to update the properties
def update_Location(self, context):
    align_to_view(context)


def find_uv(context):
    obj = context.object
    me = obj.data.vertices
    vg = obj.vertex_groups
    l = []
    index_uv = 0
    for face in obj.data.polygons:
        x = len(face.vertices)
        for vertex in face.vertices:
            if (len(me[vertex]. groups) > 0):
                for g in me[vertex].groups:
                    if vg[g.group].name == 'texture plane':
                        x -= 1

        if x == 0:
            l.append([index_uv, len(face. vertices)])
        index_uv += len(face.vertices)
    return l


# Function to update the scaleUV
def update_UVScale(self, context):
    ob = context.object
    em = bpy.data.objects[BProjection_Empty]
    v = Vector((em.custom_offsetuv[0] / 10 + 0.5, em.custom_offsetuv[1] / 10 + 0.5))
    l = Vector((0.0, 0.0))
    s = em.custom_scaleuv
    os = em.custom_old_scaleuv

    l = find_uv(context)

    for i, j in l:
        for t in range(j):
            d = ob.data.uv_layers.active.data[i + t]
            vres = v - d.uv
            d.uv.x = v.x - vres.x / os[0] * s[0]
            d.uv.y = v.y - vres.y / os[1] * s[1]

    em.custom_old_scaleuv = s

    applyimage(context)


def update_PropUVScale(self, context):
    em = bpy.data.objects[BProjection_Empty]
    if em.custom_linkscaleuv:
        em.custom_scaleuv = [em.custom_propscaleuv, em.custom_propscaleuv]


def update_LinkUVScale(self, context):
    em = bpy.data.objects[BProjection_Empty]
    if em.custom_linkscaleuv:
        em.custom_propscaleuv = em.custom_scaleuv.x
        update_PropUVScale(self, context)
    else:
        update_UVScale(self, context)


# Function to update the offsetUV
def update_UVOffset(self, context):
    ob = context.object
    em = bpy.data.objects[BProjection_Empty]
    o = em.custom_offsetuv
    oo = em.custom_old_offsetuv
    l = find_uv(context)
    for i, j in l:
        for t in range(j):
            d = ob.data.uv_layers.active.data[i + t]
            d.uv = [d.uv[0] - oo[0] / 10 + o[0] / 10, d.uv[1] - oo[1] / 10 + o[1] / 10]
    em.custom_old_offsetuv = o

    applyimage(context)


# Function to update the flip horizontal
def update_FlipUVX(self, context):
    l = find_uv(context)
    for i, j in l:
        for t in range(j):
            d = context.object.data.uv_layers.active.data[i + t]
            x = d.uv.x
            d.uv.x = 1 - x

    applyimage(context)


# Function to update the flip vertical
def update_FlipUVY(self, context):
    l = find_uv(context)
    for i, j in l: