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

505 lines
14 KiB
Python

#!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)