#!BPY

"""
Name: 'FLT Palette Manager'
Blender: 240
Group: 'Misc'
Tooltip: 'Manage FLT colors'
"""

__author__ = "Geoffrey Bantle"
__version__ = "1.0 11/21/2007"
__email__ = ('scripts', 'Author, ')
__url__ = ('blender', 'blenderartists.org')

__bpydoc__ ="""\

This script manages colors in OpenFlight databases. OpenFlight is a
registered trademark of MultiGen-Paradigm, Inc.

Todo:
-Figure out whats causing the PC speaker to beep when initializing...

Feature overview and more availible at:
http://wiki.blender.org/index.php/Scripts/Manual/FLTools
"""

# --------------------------------------------------------------------------
# flt_palettemanager.py version 1.0 2005/04/08
# --------------------------------------------------------------------------
# ***** BEGIN GPL LICENSE BLOCK *****
#
# Copyright (C) 2007: Blender Foundation
#
# 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 *****
# --------------------------------------------------------------------------

import Blender.Draw as Draw
from Blender.BGL import *
import Blender
import flt_properties
import flt_defaultp as defaultp
from flt_properties import *

def RGBtoHSV( r, g, b):
	minc = min( r, g, b )
	maxc = max( r, g, b )
	v = maxc				

	delta = maxc - minc

	if( max != 0 ):
		s = delta / maxc		
	else:
		s = 0
		h = -1
		return (h,s,v)

	if( r == maxc ):
		h = ( g - b ) / delta		
	elif( g == maxc ):
		h = 2 + ( b - r ) / delta
	else:
		h = 4 + ( r - g ) / delta

	h *= 60
	if( h < 0 ):
		h += 360

	return(h,s,v)

def HSVtoRGB(h,s,v):

	if( s == 0 ):
		return (v,v,v)
	

	h /= 60
	i = math.floor( h)
	f = h - i
	p = v * ( 1 - s )
	q = v * ( 1 - s * f )
	t = v * ( 1 - s * ( 1 - f ) )

	if i == 0:
		r = v
		g = t
		b = p
	elif i == 1:
		r = q
		g = v
		b = p

	elif i== 2:
		r = p
		g = v
		b = t
	elif i==3:
		r = p
		g = q
		b = v
	elif i==4:
		r = t
		g = p
		b = v

	else:
		r = v
		g = p
		b = q
	
	return(r,g,b)


palette_size = 12
palette_x = 0
palette_y = 0

colors = list()
curint = 1.0
curswatch = 0
#make a default palette, not very useful.
cinc = 1.0 / 1024.0
cstep = 0.0
picker = None
ptt = ""


ts1=None
ts2=None
ts3=None
ts4=None
ts5=None

for i in xrange(1024):
	colors.append([cstep,cstep,cstep])
	cstep = cstep + cinc
def update_state():
	state = dict()
	state["activeScene"] = Blender.Scene.getCurrent()
	state["activeObject"] = state["activeScene"].getActiveObject()
	state["activeMesh"] = None
	if state["activeObject"] and state["activeObject"].type == 'Mesh':
		state["activeMesh"] = state["activeObject"].getData(mesh=True)
	
	state["activeFace"] = None
	if state["activeMesh"]:
		if state["activeMesh"].faceUV and state["activeMesh"].activeFace != None:
			state["activeFace"] = state["activeMesh"].faces[state["activeMesh"].activeFace]
		
	return state
	
def pack_face_index(index, intensity):
	return ((127*intensity)+(128*index))
def unpack_face_index(face_index):
	index = face_index / 128
	intensity = float(face_index - 128.0 * index) / 127.0
	return(index,intensity)

def event(evt,val):
	global palette_size
	global palette_x
	global palette_y
	global colors
	global curint
	global curswatch
	
	areas = Blender.Window.GetScreenInfo()
	curarea = Blender.Window.GetAreaID()
	curRect = None
	editmode = 0

	for area in areas:
		if area['id'] == curarea:
			curRect = area['vertices']
			break
		
	if evt == Draw.LEFTMOUSE:
		mval = Blender.Window.GetMouseCoords()
		rastx = mval[0] - curRect[0]
		rasty = mval[1] - curRect[1]
		
		swatchx = (rastx -palette_x) / palette_size #+state["palette_x"]
		swatchy = (rasty -palette_y) / palette_size #+state["palette_y"]
                if rastx > palette_x and rastx < (palette_x + palette_size * 32) and rasty > palette_y and rasty < (palette_y+ palette_size* 32):
                        if swatchx < 32 and swatchy < 32:
                                curswatch = (swatchx * 32) + swatchy
                                Draw.Redraw(1)
		
                elif swatchy < 34 and swatchx < 32:
                        curint = 1.0 - (float(rastx-palette_x)/(palette_size*32.0))
                        Draw.Redraw(1)
	
	#copy current color and intensity to selected faces.
	elif evt == Draw.VKEY:
		
		if Blender.Window.EditMode():
			Blender.Window.EditMode(0)
			editmode = 1
		state = update_state()
		
		#retrieve color from palette
		color = struct.unpack('>BBBB',struct.pack('>i',colors[curswatch]))
		actmesh = state["activeMesh"]
		if actmesh: 
			if(Blender.Window.GetKeyQualifiers() != Blender.Window.Qual["CTRL"]):
				selfaces = list()
				for face in actmesh.faces:
					if face.sel:
						selfaces.append(face)
				
				if not "FLT_COL" in actmesh.faces.properties:
					actmesh.faces.addPropertyLayer("FLT_COL",Blender.Mesh.PropertyTypes["INT"])
					for face in actmesh.faces:
						face.setProperty("FLT_COL",127) #default
				try:
					actmesh.activeColorLayer = "FLT_Fcol"
				except:
					actmesh.addColorLayer("FLT_Fcol")
					actmesh.activeColorLayer = "FLT_Fcol"
				

				for face in selfaces:
					#First append packed index + color and store in face property
					face.setProperty("FLT_COL",int(pack_face_index(curswatch,curint))) 
					#Save baked color to face vertex colors
					for col in face.col:
						col.r = int(color[0] * curint)
						col.g = int(color[1] * curint)
						col.b = int(color[2] * curint)
						col.a = int(color[3] * curint)
			else:
				if Blender.Mesh.Mode() == Blender.Mesh.SelectModes['VERTEX']:
					if not 'FLT_VCOL' in actmesh.verts.properties:
						actmesh.verts.addPropertyLayer("FLT_VCOL",Blender.Mesh.PropertyTypes["INT"])
						for vert in actmesh.verts:
							vert.setProperty("FLT_VCOL",127)
					else:
						for vert in actmesh.verts:
							if vert.sel:
								vert.setProperty("FLT_VCOL",int(pack_face_index(curswatch,curint)))
			
			if editmode:
				Blender.Window.EditMode(1)
			
			Blender.Window.RedrawAll()
	
	#grab color and intensity from active face
	elif evt == Draw.CKEY:
		if Blender.Window.EditMode():
			Blender.Window.EditMode(0)
			editmode = 1
		state = update_state()
		
		actmesh = state["activeMesh"]
		activeFace = state["activeFace"]
		
		
		if activeFace:
			if not "FLT_COL" in actmesh.faces.properties:
				actmesh.faces.addPropertyLayer("FLT_COL",Blender.Mesh.PropertyTypes["INT"])
				for face in actmesh.faces:
					face.setProperty("FLT_COL",127) #default
			try:
				actmesh.activeColorLayer = "FLT_Fcol"
			except:
				actmesh.addColorLayer("FLT_Fcol")
				actmesh.activeColorLayer = "FLT_Fcol"
			tcol = activeFace.getProperty("FLT_COL")
			(index,intensity) = unpack_face_index(tcol)
			curswatch = index
			curint = intensity
			
		if editmode:
			Blender.Window.EditMode(1)
		
		Blender.Window.RedrawAll()
		
	elif evt == Draw.GKEY:
		if Blender.Window.EditMode():
			Blender.Window.EditMode(0)
			editmode =1
		state = update_state()
		
		actmesh = state["activeMesh"]
		activeFace = state["activeFace"]
		
		if activeFace and "FLT_COL" in actmesh.faces.properties:
			(index,intensity) = unpack_face_index(activeFace.getProperty("FLT_COL"))
			for face in actmesh.faces:
				(index2, intensity2) = unpack_face_index(face.getProperty("FLT_COL"))
				if index == index2:
					face.sel = 1
				
			
	elif evt == Draw.ESCKEY:
		Draw.Exit()
	
	if editmode:
		Blender.Window.EditMode(1)

def update_all():
	global colors
	state = update_state()
	#update the baked FLT colors for all meshes.
	for object in state["activeScene"].objects:
		if object.type == "Mesh":
			mesh = object.getData(mesh=True)
			if 'FLT_COL' in mesh.faces.properties and "FLT_Fcol" in mesh.getColorLayerNames():
				mesh.activeColorLayer = "FLT_Fcol"
				for face in mesh.faces:
					(index,intensity) = unpack_face_index(face.getProperty('FLT_COL'))
					color = struct.unpack('>BBBB',struct.pack('>i',colors[index]))
					#update the vertex colors for this face
					for col in face.col:
						col.r = int(color[0] * intensity)
						col.g = int(color[1] * intensity)
						col.b = int(color[2] * intensity)
						col.a = 255


def but_event(evt):
	global palette_size
	global palette_x
	global palette_y
	global colors
	global curint
	global curswatch
	global picker
	state = update_state()

	if evt == 1:
 		if picker.val:
			rval = (int(picker.val[0]*255),int(picker.val[1]*255),int(picker.val[2]*255),255)
			rval = struct.pack('>BBBB',rval[0],rval[1],rval[2],rval[3])
			rval = struct.unpack('>i',rval)
			colors[curswatch] = rval[0]	
			#go cd through all meshes and update their FLT colors
			update_all()

	Draw.Redraw(1)
def init_pal():
	global palette_size
	global palette_x
	global palette_y
	global colors
	global curint
	global curswatch
	
	state = update_state()

	if not state["activeScene"].properties.has_key('FLT'):
		state["activeScene"].properties['FLT'] = dict()

	try:
		colors = state["activeScene"].properties['FLT']['Color Palette']
	except:
		state["activeScene"].properties['FLT']['Color Palette'] = defaultp.pal
		colors = state["activeScene"].properties['FLT']['Color Palette']

def draw_palette():
	global palette_size
	global palette_x
	global palette_y
	global colors
	global curint
	global curswatch
	global picker
	global ts1
	global ts2
	global ts3
	global ts4
	global ts5
	
	state = update_state()
	init_pal()

	ssize = palette_size
	xpos = palette_x
	cid = 0

	highlight = [(palette_x,palette_y),(palette_x+palette_size,palette_y),(palette_x+palette_size,palette_y+palette_size),(palette_x,palette_y+palette_size)]
	for x in xrange(32):
		ypos = palette_y
		for y in xrange(32):
			color = struct.unpack('>BBBB',struct.pack('>i',colors[cid]))
			glColor3f(color[0]/255.0,color[1]/255.0,color[2]/255.0)
			glBegin(GL_POLYGON)
			glVertex2i(xpos,ypos)
			glVertex2i(xpos+ssize,ypos)
			glVertex2i(xpos+ssize,ypos+ssize)
			glVertex2i(xpos,ypos+ssize)				
			glEnd()
			
			if curswatch == cid:
				highlight[0] = (xpos,ypos)
				highlight[1] = (xpos+ssize,ypos)
				highlight[2] = (xpos+ssize,ypos+ssize)
				highlight[3] = (xpos,ypos+ssize)
		
			glColor3f(0.0,0.0,0.0)
			glBegin(GL_LINE_LOOP)
			glVertex2i(xpos,ypos)
			glVertex2i(xpos+ssize,ypos)
			glVertex2i(xpos+ssize,ypos+ssize)
			glVertex2i(xpos,ypos+ssize)
			glVertex2i(xpos,ypos)				
			glEnd()			
				
			
			cid = cid + 1
			ypos = ypos + ssize
		
		xpos = xpos + ssize
	
	#draw intensity gradient
	color = struct.unpack('>BBBB',struct.pack('>i',colors[curswatch]))
	color = [color[0]/255.0,color[1]/255.0,color[2]/255.0]
	colsteps = [color[0]/255.0,color[1]/255.0,color[2]/255.0]
	stripwidth = (palette_size * 32.0) / 256
	strippad = palette_size / 2.0
	
	xpos = palette_x
	grady = (palette_y + (palette_size * 32.0)) + strippad
	for x in xrange(256):
		color[0] = color[0] - colsteps[0]
		color[1] = color[1] - colsteps[1] 
		color[2] = color[2] - colsteps[2]

		glColor3f(color[0], color[1] ,color[2])
		glBegin(GL_POLYGON)
		glVertex2f(xpos,grady)
		glVertex2f(xpos+stripwidth,grady)
		glVertex2f(xpos+stripwidth,grady+palette_size)
		glVertex2f(xpos,grady+palette_size)
		glEnd()
		xpos = xpos + stripwidth
		
	#draw intensity slider bar
	#xposition ==  512 - ((curint) * 512)
	xpos = ((palette_size*32) * (1.0 - curint)) + palette_x
	glColor3f(1.0,1.0,1.0)
	glBegin(GL_LINE_LOOP)
	glVertex2i(int(xpos-6),int(grady-1))
	glVertex2i(int(xpos+6),int(grady-1))
	glVertex2i(int(xpos+6),int(grady+palette_size+1))
	glVertex2i(int(xpos-6),int(grady+palette_size+1))
	#glVertex2i(xpos-6,grady+7)
	glEnd()

	#draw color picker
	color = struct.unpack('>BBBB',struct.pack('>i',colors[curswatch]))
	pickcol = (color[0]/255.0,color[1]/255.0,color[2]/255.0)
	picker = Blender.Draw.ColorPicker(1,highlight[0][0]+1,highlight[0][1]+1,ssize-2,ssize-2,pickcol,ptt)

	#draw highlight swatch
	glColor3f(1.0,1.0,1.0)
	glBegin(GL_LINE_LOOP)
	glVertex2i(highlight[0][0],highlight[0][1])
	glVertex2i(highlight[1][0],highlight[1][1])
	glVertex2i(highlight[2][0],highlight[2][1])
	glVertex2i(highlight[3][0],highlight[3][1])
	glVertex2i(highlight[0][0],highlight[0][1])
	glEnd()			

	#draw text string explanations
	xpos = palette_size*32+20
	ypos = palette_size*32+10
	glRasterPos2d(xpos,ypos)
	ts1	= Blender.Draw.Text("FLT Palette Manager V 1.0")
	ypos = ypos - 20
	glRasterPos2d(xpos,ypos)
	ts3 = Blender.Draw.Text("CKEY - Copy Active Face Color*")
	ypos = ypos - 20
	glRasterPos2d(xpos,ypos)
	ts2 = Blender.Draw.Text("VKEY - Paste Color to Selected Faces")
	ypos = ypos - 20
	glRasterPos2d(xpos,ypos)
	ts4 = Blender.Draw.Text("GKEY - Select Faces With Same Color")
	ypos = ypos - 15
	glRasterPos2d(xpos,ypos)
	ts5 = Blender.Draw.Text("(*Requires mesh with UV coordinates)", 'small')

def gui():
	glClearColor(0.5,0.5,0.5,1.0)
	glClear(GL_COLOR_BUFFER_BIT)
	draw_palette()


init_pal()
Draw.Register(gui,event,but_event)