space_view3d_paint_bprojection.py

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

import bpy
from bpy.app.handlers import persistent
from bpy.types import Panel, Operator
from bpy.props import IntProperty, FloatProperty, BoolProperty, IntVectorProperty, StringProperty, FloatVectorProperty, CollectionProperty
from bpy_extras import view3d_utils
import math
from math import *
import mathutils
from mathutils import *

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]

    reg = context.region
    width = reg.width
    height = reg.height

    sd = context.space_data
    r3d = sd.region_3d
    r3d.update()
    vr = r3d.view_rotation
    quat = mathutils.Quaternion((0.0, 0.0, 1.0), math.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
        em = bpy.data.objects[BProjection_Empty]
        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
    scale = s - os
    l = find_uv(context)
    for i,j in l:
        for t in range(j):
            d = context.object.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 = context.object.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:
        for t in range(j):
            d = context.object.data.uv_layers.active.data[i+t]
            y = d.uv[1]
            d.uv[1] = 1 - y

    applyimage(context)

# Function to update
def update_Rotation(self, context):
    ob = context.object
    em = bpy.data.objects[BProjection_Empty]
    if em.custom_rotc3d:
        angle = em.custom_rotation - em.custom_old_rotation
        sd = context.space_data
        vr = sd.region_3d.view_rotation.copy()
        c = sd.cursor_location - ob.location
        e = bpy.data.objects[BProjection_Empty].location - ob.location
        vo = Vector((0.0, 0.0, 1.0))
        vo.rotate(vr)
        quat = mathutils.Quaternion(vo, math.radians(angle))
        v = e-c
        v.rotate(quat)
        vr.invert()
        v.rotate(vr)
        c.rotate(vr)
        em.custom_location = c + v