Blender-ZeroEngine-MSH2-Plugin/src_research_readme/blender_2.43_scripts/uvcalc_lightmap.py

#!BPY
"""
Name: 'Lightmap UVPack'
Blender: 242
Group: 'UVCalculation'
Tooltip: 'Give each face non overlapping space on a texture.'
"""
__author__ = "Campbell Barton aka ideasman42"
__url__ = ("blender", "blenderartists.org")
__version__ = "1.0 2006/02/07"

__bpydoc__ = """\
"""

# ***** BEGIN GPL LICENSE BLOCK *****
#
# Script copyright (C) Campbell Barton
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#
# ***** END GPL LICENCE BLOCK *****
# --------------------------------------------------------------------------


from Blender import *
import bpy
import BPyMesh
# reload(BPyMesh)

from math import sqrt

def AngleBetweenVecs(a1,a2):
	try:
		return Mathutils.AngleBetweenVecs(a1,a2)
	except:
		return 180.0

# python 2.3 has no reversed() iterator. this will only work on lists and tuples
try:
	reversed
except:
	def reversed(l): return l[::-1]

class prettyface(object):
	__slots__ = 'uv', 'width', 'height', 'children', 'xoff', 'yoff', 'has_parent', 'rot'
	def __init__(self, data):
		
		self.has_parent = False
		self.rot = False # only used for triables
		self.xoff = 0
		self.yoff = 0
		
		if type(data) == list: # list of data
			self.uv = None
			
			# join the data
			if len(data) == 2:
				# 2 vertical blocks
				data[1].xoff = data[0].width
				self.width  = data[0].width * 2
				self.height = data[0].height
			
			elif len(data) == 4:
				# 4 blocks all the same size
				d = data[0].width # dimension x/y are the same
				
				data[1].xoff += d
				data[2].yoff += d
				
				data[3].xoff += d
				data[3].yoff += d
				
				self.width = self.height = d*2
				
			#else:
			#	print len(data), data
			#	raise "Error"
			
			for pf in data:
				pf.has_parent = True
			
			
			self.children = data
			
		elif type(data) == tuple:
			# 2 blender faces
			# f, (len_min, len_mid, len_max)
			self.uv = data
			
			f1, lens1, lens1ord = data[0] 			
			if data[1]:
				f2, lens2, lens2ord = data[1]
				self.width  = (lens1[lens1ord[0]] + lens2[lens2ord[0]])/2
				self.height = (lens1[lens1ord[1]] + lens2[lens2ord[1]])/2
			else: # 1 tri :/
				self.width = lens1[0]
				self.height = lens1[1]
			
			self.children = []
			
			
		else: # blender face
			self.uv = data.uv
			
			cos = [v.co for v in data]
			self.width  = ((cos[0]-cos[1]).length + (cos[2]-cos[3]).length)/2
			self.height = ((cos[1]-cos[2]).length + (cos[0]-cos[3]).length)/2
			
			self.children = []
		
		
	def spin(self):
		if self.uv and len(self.uv) == 4:
			self.uv = self.uv[1], self.uv[2], self.uv[3], self.uv[0]
		
		self.width, self.height = self.height, self.width
		self.xoff, self.yoff = self.yoff, self.xoff # not needed?
		self.rot = not self.rot # only for tri pairs.
		# print 'spinning'
		for pf in self.children:
			pf.spin()
	
	
	def place(self, xoff, yoff, xfac, yfac, margin_w, margin_h):
		
		xoff += self.xoff
		yoff += self.yoff
		
		for pf in self.children:
			pf.place(xoff, yoff, xfac, yfac, margin_w, margin_h)
		
		uv = self.uv
		if not uv:
			return
		
		x1 = xoff
		y1 = yoff
		x2 = xoff + self.width
		y2 = yoff + self.height
		
		# Scale the values
		x1 = x1/xfac + margin_w
		x2 = x2/xfac - margin_w
		y1 = y1/yfac + margin_h
		y2 = y2/yfac - margin_h
		
		# 2 Tri pairs
		if len(uv) == 2:
			# match the order of angle sizes of the 3d verts with the UV angles and rotate.
			def get_tri_angles(v1,v2,v3):
				a1= AngleBetweenVecs(v2-v1,v3-v1)
				a2= AngleBetweenVecs(v1-v2,v3-v2)
				a3 = 180 - (a1+a2) #a3= AngleBetweenVecs(v2-v3,v1-v3)
				
				
				return [(a1,0),(a2,1),(a3,2)]
			
			def set_uv(f, p1, p2, p3):
				
				# cos = 
				#v1 = cos[0]-cos[1]
				#v2 = cos[1]-cos[2]
				#v3 = cos[2]-cos[0]
				angles_co = get_tri_angles(*[v.co for v in f])
				angles_co.sort()
				I = [i for a,i in angles_co]
				
				fuv = f.uv
				if self.rot:
					fuv[I[2]][:] = p1
					fuv[I[1]][:] = p2
					fuv[I[0]][:] = p3
				else:
					fuv[I[2]][:] = p1
					fuv[I[0]][:] = p2
					fuv[I[1]][:] = p3
			
			f, lens, lensord = uv[0]
			
			set_uv(f,  (x1,y1),  (x1, y2-margin_h),  (x2-margin_w, y1))
			
			if uv[1]:
				f, lens, lensord = uv[1]
				set_uv(f,  (x2,y2),  (x2, y1+margin_h),  (x1+margin_w, y2))
			
		else: # 1 QUAD
			uv[1][:] = x1,y1
			uv[2][:] = x1,y2
			uv[3][:] = x2,y2
			uv[0][:] = x2,y1
	
	def __hash__(self):
		# None unique hash
		return self.width, self.height


def lightmap_uvpack(	meshes,\
PREF_SEL_ONLY=			True,\
PREF_NEW_UVLAYER=		False,\
PREF_PACK_IN_ONE=		False,\
PREF_APPLY_IMAGE=		False,\
PREF_IMG_PX_SIZE=		512,\
PREF_BOX_DIV= 			8,\
PREF_MARGIN_DIV=		512):
	'''
	BOX_DIV if the maximum division of the UV map that
	a box may be consolidated into.
	Basicly, a lower value will be slower but waist less space
	and a higher value will have more clumpy boxes but more waisted space
	'''
	
	if not meshes:
		return
	
	t = sys.time()
	
	if PREF_PACK_IN_ONE:
		if PREF_APPLY_IMAGE:
			image = Image.New('lightmap', PREF_IMG_PX_SIZE, PREF_IMG_PX_SIZE, 24)
		face_groups = [[]]
	else:
		face_groups = []
	
	for me in meshes:
		# Add face UV if it does not exist.
		# All new faces are selected.
		me.faceUV = True
			
		if PREF_SEL_ONLY:
			faces = [f for f in me.faces if f.sel]
		else:
			faces = list(me.faces)
		
		if PREF_PACK_IN_ONE:
			face_groups[0].extend(faces)
		else:
			face_groups.append(faces)
		
		if PREF_NEW_UVLAYER:
			uvname_org = uvname = 'lightmap'
			uvnames = me.getUVLayerNames()
			i = 1
			while uvname in uvnames:
				uvname = '%s.%03d' % (uvname_org, i)
				i+=1
			
			me.addUVLayer(uvname)
			me.activeUVLayer = uvname
			
			del uvnames, uvname_org, uvname
	
	for face_sel in face_groups:
		print "\nStarting unwrap"
		
		if len(face_sel) <4:
			print '\tWarning, less then 4 faces, skipping'
			continue
		
		pretty_faces = [prettyface(f) for f in face_sel if len(f) == 4]
		
		
		# Do we have any tri's
		if len(pretty_faces) != len(face_sel):
			
			# Now add tri's, not so simple because we need to pair them up.
			def trylens(f):
				# f must be a tri
				cos = [v.co for v in f]
				lens = [(cos[0] - cos[1]).length, (cos[1] - cos[2]).length, (cos[2] - cos[0]).length]
				
				lens_min = lens.index(min(lens))
				lens_max = lens.index(max(lens))
				for i in xrange(3):
					if i != lens_min and i!= lens_max:
						lens_mid = i
						break
				lens_order = lens_min, lens_mid, lens_max
				
				return f, lens, lens_order
				
			tri_lengths = [trylens(f) for f in face_sel if len(f) == 3]
			del trylens
			
			def trilensdiff(t1,t2):
				return\
				abs(t1[1][t1[2][0]]-t2[1][t2[2][0]])+\
				abs(t1[1][t1[2][1]]-t2[1][t2[2][1]])+\
				abs(t1[1][t1[2][2]]-t2[1][t2[2][2]])
			
			while tri_lengths:
				tri1 = tri_lengths.pop()
				
				if not tri_lengths:
					pretty_faces.append(prettyface((tri1, None)))
					break
				
				best_tri_index = -1
				best_tri_diff  = 100000000.0
				
				for i, tri2 in enumerate(tri_lengths):
					diff = trilensdiff(tri1, tri2)
					if diff < best_tri_diff:
						best_tri_index = i
						best_tri_diff = diff
				
				pretty_faces.append(prettyface((tri1, tri_lengths.pop(best_tri_index))))
		
		
		# Get the min, max and total areas
		max_area = 0.0
		min_area = 100000000.0
		tot_area = 0
		for f in face_sel:
			area = f.area
			if area > max_area:		max_area = area
			if area < min_area:		min_area = area
			tot_area += area
			
		max_len = sqrt(max_area)
		min_len = sqrt(min_area)
		side_len = sqrt(tot_area) 
		
		# Build widths
		
		curr_len = max_len
		
		print '\tGenerating lengths...',
		
		lengths = []
		while curr_len > min_len:
			lengths.append(curr_len) 
			curr_len = curr_len/2
			
			# Dont allow boxes smaller then the margin
			# since we contract on the margin, boxes that are smaller will create errors
			# print curr_len, side_len/MARGIN_DIV
			if curr_len/4 < side_len/PREF_MARGIN_DIV:
				break
		
		if not lengths:
			lengths.append(curr_len)
		
		# convert into ints
		lengths_to_ints = {}
		
		l_int = 1
		for l in reversed(lengths):
			lengths_to_ints[l] = l_int
			l_int*=2
		
		lengths_to_ints = lengths_to_ints.items()
		lengths_to_ints.sort()
		print 'done'
		
		# apply quantized values.
		
		for pf in pretty_faces:
			w = pf.width
			h = pf.height
			bestw_diff = 1000000000.0
			besth_diff = 1000000000.0
			new_w = 0.0
			new_h = 0.0
			for l, i in lengths_to_ints:
				d = abs(l - w)
				if d < bestw_diff:
					bestw_diff = d
					new_w = i # assign the int version
				
				d = abs(l - h)
				if d < besth_diff:
					besth_diff = d
					new_h = i # ditto
			
			pf.width = new_w
			pf.height = new_h
			
			if new_w > new_h:
				pf.spin()
			
		print '...done'
		
		
		# Since the boxes are sized in powers of 2, we can neatly group them into bigger squares
		# this is done hierarchily, so that we may avoid running the pack function
		# on many thousands of boxes, (under 1k is best) because it would get slow.
		# Using an off and even dict us usefull because they are packed differently
		# where w/h are the same, their packed in groups of 4
		# where they are different they are packed in pairs
		#
		# After this is done an external pack func is done that packs the whole group.
		
		print '\tConsolidating Boxes...',
		even_dict = {} # w/h are the same, the key is an int (w)
		odd_dict = {} # w/h are different, the key is the (w,h)
		
		for pf in pretty_faces:
			w,h = pf.width, pf.height
			if w==h:	even_dict.setdefault(w, []).append( pf )
			else:		odd_dict.setdefault((w,h), []).append( pf )
		
		# Count the number of boxes consolidated, only used for stats.
		c = 0
		
		# This is tricky. the total area of all packed boxes, then squt that to get an estimated size
		# this is used then converted into out INT space so we can compare it with 
		# the ints assigned to the boxes size
		# and divided by BOX_DIV, basicly if BOX_DIV is 8
		# ...then the maximum box consolidataion (recursive grouping) will have a max width & height
		# ...1/8th of the UV size.
		# ...limiting this is needed or you end up with bug unused texture spaces
		# ...however if its too high, boxpacking is way too slow for high poly meshes.
		float_to_int_factor = lengths_to_ints[0][0]
		if float_to_int_factor > 0:
			max_int_dimension = int(((side_len / float_to_int_factor)) / PREF_BOX_DIV)
			ok = True
		else:
			max_int_dimension = 0.0 # wont be used
			ok = False
		
		# RECURSIVE prettyface grouping
		while ok:
			ok = False
			
			# Tall boxes in groups of 2
			for d, boxes in odd_dict.items():
				if d[1] < max_int_dimension:
					#\boxes.sort(key = lambda a: len(a.children))
					while len(boxes) >= 2:
						# print "foo", len(boxes)
						ok = True
						c += 1
						pf_parent = prettyface([boxes.pop(), boxes.pop()])
						pretty_faces.append(pf_parent)
						
						w,h = pf_parent.width, pf_parent.height
						
						if w>h: raise "error"
						
						if w==h:
							even_dict.setdefault(w, []).append(pf_parent)
						else:
							odd_dict.setdefault((w,h), []).append(pf_parent)
					
			# Even boxes in groups of 4
			for d, boxes in even_dict.items():	
				if d < max_int_dimension:
					# py 2.3 compat
					try:	boxes.sort(key = lambda a: len(a.children))
					except:	boxes.sort(lambda a, b: cmp(len(a.children), len(b.children)))
					
					while len(boxes) >= 4:
						# print "bar", len(boxes)
						ok = True
						c += 1
						
						pf_parent = prettyface([boxes.pop(), boxes.pop(), boxes.pop(), boxes.pop()])
						pretty_faces.append(pf_parent)
						w = pf_parent.width # width and weight are the same 
						even_dict.setdefault(w, []).append(pf_parent)
		
		del even_dict
		del odd_dict
		
		orig = len(pretty_faces)
		
		pretty_faces = [pf for pf in pretty_faces if not pf.has_parent]
		
		# spin every second prettyface
		# if there all vertical you get less efficiently used texture space
		i = len(pretty_faces)
		d = 0
		while i:
			i -=1
			pf = pretty_faces[i]
			if pf.width != pf.height:
				d += 1
				if d % 2: # only pack every second
					pf.spin()
					# pass
		
		print 'Consolidated', c, 'boxes, done'
		# print 'done', orig, len(pretty_faces)
		
		
		# boxes2Pack.append([islandIdx, w,h])
		print '\tPacking Boxes', len(pretty_faces), '...',
		boxes2Pack = [ [0.0, 0.0, pf.width, pf.height, i] for i, pf in enumerate(pretty_faces)]
		packWidth, packHeight = Geometry.BoxPack2D(boxes2Pack)
		
		# print packWidth, packHeight
		
		packWidth = float(packWidth)
		packHeight = float(packHeight)
		
		margin_w = ((packWidth) / PREF_MARGIN_DIV)/ packWidth
		margin_h = ((packHeight) / PREF_MARGIN_DIV) / packHeight
		
		# print margin_w, margin_h
		print 'done'
		
		# Apply the boxes back to the UV coords.
		print '\twriting back UVs',
		for i, box in enumerate(boxes2Pack):
			pretty_faces[i].place(box[0], box[1], packWidth, packHeight, margin_w, margin_h)
			# pf.place(box[1][1], box[1][2], packWidth, packHeight, margin_w, margin_h)
		print 'done'
		
		
		if PREF_APPLY_IMAGE:
			if not PREF_PACK_IN_ONE:
				image = Image.New('lightmap', PREF_IMG_PX_SIZE, PREF_IMG_PX_SIZE, 24)
				
			for f in face_sel:
				f.image = image
		
	for me in meshes:
		me.update()
	
	print 'finished all %.2f ' % (sys.time() - t)
	
	Window.RedrawAll()

def main():
	scn = bpy.data.scenes.active
	
	PREF_ACT_ONLY = Draw.Create(1)
	PREF_SEL_ONLY = Draw.Create(1)
	PREF_NEW_UVLAYER = Draw.Create(0)
	PREF_PACK_IN_ONE = Draw.Create(0)
	PREF_APPLY_IMAGE = Draw.Create(0)
	PREF_IMG_PX_SIZE = Draw.Create(512)
	PREF_BOX_DIV = Draw.Create(12)
	PREF_MARGIN_DIV = Draw.Create(0.1)
	
	if not Draw.PupBlock('Lightmap Pack', [\
	'Context...',
	('Active Object', PREF_ACT_ONLY, 'If disabled, include other selected objects for packing the lightmap.'),\
	('Selected Faces', PREF_SEL_ONLY, 'Use only selected faces from all selected meshes.'),\
	'Image & UVs...',
	('Share Tex Space', PREF_PACK_IN_ONE, 'Objects Share texture space, map all objects into 1 uvmap'),\
	('New UV Layer', PREF_NEW_UVLAYER, 'Create a new UV layer for every mesh packed'),\
	('New Image', PREF_APPLY_IMAGE, 'Assign new images for every mesh (only one if shared tex space enabled)'),\
	('Image Size', PREF_IMG_PX_SIZE, 64, 5000, 'Width and Height for the new image'),\
	'UV Packing...',
	('Pack Quality: ', PREF_BOX_DIV, 1, 48, 'Pre Packing before the complex boxpack'),\
	('Margin: ', PREF_MARGIN_DIV, 0.001, 1.0, 'Size of the margin as a division of the UV')\
	]):
		return
	
	
	if PREF_ACT_ONLY.val:
		ob = scn.objects.active
		if ob == None or ob.type != 'Mesh':
			Draw.PupMenu('Error%t|No mesh object.')
			return
		meshes = [ ob.getData(mesh=1) ]
	else:
		meshes = dict([ (me.name, me) for ob in scn.objects.context if ob.type == 'Mesh' for me in (ob.getData(mesh=1),) if not me.lib if len(me.faces)])
		meshes = meshes.values()
		if not meshes:
			Draw.PupMenu('Error%t|No mesh objects selected.')
			return
	
	# Toggle Edit mode
	is_editmode = Window.EditMode()
	if is_editmode:
		Window.EditMode(0)


	Window.WaitCursor(1)
	lightmap_uvpack(meshes,\
			PREF_SEL_ONLY.val,\
			PREF_NEW_UVLAYER.val,\
			PREF_PACK_IN_ONE.val,\
			PREF_APPLY_IMAGE.val,\
			PREF_IMG_PX_SIZE.val,\
			PREF_BOX_DIV.val,\
			int(1/(PREF_MARGIN_DIV.val/100)))
	
	if is_editmode:
		Window.EditMode(1)
	
	Window.WaitCursor(0)

if __name__ == '__main__':
	main()