blender/release/scripts/md2_export.py

1017 lines
30 KiB
Python
Raw Normal View History

#!BPY
"""
Name: 'MD2 (.md2)'
Blender: 239
Group: 'Export'
Tooltip: 'Export to Quake file format (.md2).'
"""
__author__ = 'Bob Holcomb'
__version__ = '0.16'
__url__ = ["Bob's site, http://bane.servebeer.com",
"Support forum, http://scourage.servebeer.com/phpbb/", "blender", "elysiun"]
__email__ = ["Bob Holcomb, bob_holcomb:hotmail*com", "scripts"]
__bpydoc__ = """\
This script Exports a Quake 2 file (MD2).
Additional help from: Shadwolf, Skandal, Rojo, Cambo<br>
Thanks Guys!
"""
# ***** BEGIN GPL LICENSE BLOCK *****
#
# Script copyright (C): Bob Holcomb
#
# 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
from Blender import *
from Blender.Draw import *
from Blender.BGL import *
from Blender.Window import *
import struct, string
from types import *
######################################################
# GUI Loader
######################################################
# Export globals
g_filename=Create("/home/bob/work/blender_scripts/md2/test-export.md2")
g_frame_filename=Create("default")
g_filename_search=Create("model")
g_frame_search=Create("default")
user_frame_list=[]
#Globals
g_scale=Create(1.0)
# Events
EVENT_NOEVENT=1
EVENT_SAVE_MD2=2
EVENT_CHOOSE_FILENAME=3
EVENT_CHOOSE_FRAME=4
EVENT_EXIT=100
######################################################
# Callbacks for Window functions
######################################################
def filename_callback(input_filename):
global g_filename
g_filename.val=input_filename
def frame_callback(input_frame):
global g_frame_filename
g_frame_filename.val=input_frame
def draw_gui():
global g_scale
global g_filename
global g_frame_filename
global EVENT_NOEVENT,EVENT_SAVE_MD2,EVENT_CHOOSE_FILENAME,EVENT_CHOOSE_FRAME,EVENT_EXIT
########## Titles
glClear(GL_COLOR_BUFFER_BIT)
glRasterPos2d(8, 103)
Text("MD2 Export")
######### Parameters GUI Buttons
g_filename = String("MD2 file to save: ", EVENT_NOEVENT, 10, 55, 210, 18,
g_filename.val, 255, "MD2 file to save")
########## MD2 File Search Button
Button("Search",EVENT_CHOOSE_FILENAME,220,55,80,18)
g_frame_filename = String("Frame List file to load: ", EVENT_NOEVENT, 10, 35, 210, 18,
g_frame_filename.val, 255, "Frame List to load-overrides MD2 defaults")
########## Texture Search Button
Button("Search",EVENT_CHOOSE_FRAME,220,35,80,18)
########## Scale slider-default is 1/8 which is a good scale for md2->blender
g_scale= Slider("Scale Factor: ", EVENT_NOEVENT, 10, 75, 210, 18,
1.0, 0.001, 10.0, 1, "Scale factor for obj Model");
######### Draw and Exit Buttons
Button("Export",EVENT_SAVE_MD2 , 10, 10, 80, 18)
Button("Exit",EVENT_EXIT , 170, 10, 80, 18)
def event(evt, val):
if (evt == QKEY and not val):
Exit()
def bevent(evt):
global g_filename
global g_frame_filename
global EVENT_NOEVENT,EVENT_SAVE_MD2,EVENT_EXIT
######### Manages GUI events
if (evt==EVENT_EXIT):
Blender.Draw.Exit()
elif (evt==EVENT_CHOOSE_FILENAME):
FileSelector(filename_callback, "MD2 File Selection")
elif (evt==EVENT_CHOOSE_FRAME):
FileSelector(frame_callback, "Frame Selection")
elif (evt==EVENT_SAVE_MD2):
if (g_filename.val == "model"):
save_md2("blender.md2")
Blender.Draw.Exit()
return
else:
save_md2(g_filename.val)
Blender.Draw.Exit()
return
Register(draw_gui, event, bevent)
######################################################
# MD2 Model Constants
######################################################
MD2_MAX_TRIANGLES=4096
MD2_MAX_VERTICES=2048
MD2_MAX_TEXCOORDS=2048
MD2_MAX_FRAMES=512
MD2_MAX_SKINS=32
MD2_MAX_FRAMESIZE=(MD2_MAX_VERTICES * 4 + 128)
MD2_FRAME_NAME_LIST=(("stand",1,40),
("run",41,46),
("attack",47,54),
("pain1",55,58),
("pain2",59,62),
("pain3",63,66),
("jump",67,72),
("flip",73,84),
("salute", 85,95),
("taunt",96,112),
("wave",113,123),
("point",124,135),
("crstnd",136,154),
("crwalk",155,160),
("crattack",161,169),
("crpain",170,173),
("crdeath",174,178),
("death1",179,184),
("death2",185,190),
("death3",191,198))
#198 frames
######################################################
# MD2 data structures
######################################################
class md2_point:
vertices=[]
lightnormalindex=0
binary_format="<3BB"
def __init__(self):
self.vertices=[0]*3
self.lightnormalindex=0
def save(self, file):
temp_data=[0]*4
temp_data[0]=self.vertices[0]
temp_data[1]=self.vertices[1]
temp_data[2]=self.vertices[2]
temp_data[3]=self.lightnormalindex
data=struct.pack(self.binary_format, temp_data[0], temp_data[1], temp_data[2], temp_data[3])
file.write(data)
def dump(self):
print "MD2 Point Structure"
print "vertex X: ", self.vertices[0]
print "vertex Y: ", self.vertices[1]
print "vertex Z: ", self.vertices[2]
print "lightnormalindex: ",self.lightnormalindex
print ""
class md2_face:
vertex_index=[]
texture_index=[]
binary_format="<3h3h"
def __init__(self):
self.vertex_index = [ 0, 0, 0 ]
self.texture_index = [ 0, 0, 0]
def save(self, file):
temp_data=[0]*6
#swap vertices around so they draw right
temp_data[0]=self.vertex_index[0]
temp_data[1]=self.vertex_index[2]
temp_data[2]=self.vertex_index[1]
#swap texture vertices around so they draw right
temp_data[3]=self.texture_index[0]
temp_data[4]=self.texture_index[2]
temp_data[5]=self.texture_index[1]
data=struct.pack(self.binary_format,temp_data[0],temp_data[1],temp_data[2],temp_data[3],temp_data[4],temp_data[5])
file.write(data)
def dump (self):
print "MD2 Face Structure"
print "vertex 1 index: ", self.vertex_index[0]
print "vertex 2 index: ", self.vertex_index[1]
print "vertex 3 index: ", self.vertex_index[2]
print "texture 1 index: ", self.texture_index[0]
print "texture 2 index: ", self.texture_index[1]
print "texture 3 index: ", self.texture_index[2]
print ""
class md2_tex_coord:
u=0
v=0
binary_format="<2h"
def __init__(self):
self.u=0
self.v=0
def save(self, file):
temp_data=[0]*2
temp_data[0]=self.u
temp_data[1]=self.v
data=struct.pack(self.binary_format, temp_data[0], temp_data[1])
file.write(data)
def dump (self):
print "MD2 Texture Coordinate Structure"
print "texture coordinate u: ",self.u
print "texture coordinate v: ",self.v
print ""
class md2_GL_command:
s=0.0
t=0.0
vert_index=0
binary_format="<2fi"
def __init__(self):
self.s=0.0
self.t=0.0
vert_index=0
def save(self,file):
temp_data=[0]*3
temp_data[0]=float(self.s)
temp_data[1]=float(self.t)
temp_data[2]=self.vert_index
data=struct.pack(self.binary_format, temp_data[0],temp_data[1],temp_data[2])
file.write(data)
def dump (self):
print "MD2 OpenGL Command"
print "s: ", self.s
print "t: ", self.t
print "Vertex Index: ", self.vert_index
print ""
class md2_GL_cmd_list:
num=0
cmd_list=[]
binary_format="<i"
def __init__(self):
self.num=0
self.cmd_list=[]
def save(self,file):
data=struct.pack(self.binary_format, self.num)
file.write(data)
for cmd in self.cmd_list:
cmd.save(file)
def dump(self):
print "MD2 OpenGL Command List"
print "number: ", self.num
for cmd in self.cmd_list:
cmd.dump()
print ""
class md2_skin:
name=""
binary_format="<64s"
def __init__(self):
self.name=""
def save(self, file):
temp_data=self.name
data=struct.pack(self.binary_format, temp_data)
file.write(data)
def dump (self):
print "MD2 Skin"
print "skin name: ",self.name
print ""
class md2_frame:
scale=[]
translate=[]
name=[]
vertices=[]
binary_format="<3f3f16s"
def __init__(self):
self.scale=[0.0]*3
self.translate=[0.0]*3
self.name=""
self.vertices=[]
def save(self, file):
temp_data=[0]*7
temp_data[0]=float(self.scale[0])
temp_data[1]=float(self.scale[1])
temp_data[2]=float(self.scale[2])
temp_data[3]=float(self.translate[0])
temp_data[4]=float(self.translate[1])
temp_data[5]=float(self.translate[2])
temp_data[6]=self.name
data=struct.pack(self.binary_format, temp_data[0],temp_data[1],temp_data[2],temp_data[3],temp_data[4],temp_data[5],temp_data[6])
file.write(data)
def dump (self):
print "MD2 Frame"
print "scale x: ",self.scale[0]
print "scale y: ",self.scale[1]
print "scale z: ",self.scale[2]
print "translate x: ",self.translate[0]
print "translate y: ",self.translate[1]
print "translate z: ",self.translate[2]
print "name: ",self.name
print ""
class md2_obj:
#Header Structure
ident=0 #int 0 This is used to identify the file
version=0 #int 1 The version number of the file (Must be 8)
skin_width=0 #int 2 The skin width in pixels
skin_height=0 #int 3 The skin height in pixels
frame_size=0 #int 4 The size in bytes the frames are
num_skins=0 #int 5 The number of skins associated with the model
num_vertices=0 #int 6 The number of vertices (constant for each frame)
num_tex_coords=0 #int 7 The number of texture coordinates
num_faces=0 #int 8 The number of faces (polygons)
num_GL_commands=0 #int 9 The number of gl commands
num_frames=0 #int 10 The number of animation frames
offset_skins=0 #int 11 The offset in the file for the skin data
offset_tex_coords=0 #int 12 The offset in the file for the texture data
offset_faces=0 #int 13 The offset in the file for the face data
offset_frames=0 #int 14 The offset in the file for the frames data
offset_GL_commands=0#int 15 The offset in the file for the gl commands data
offset_end=0 #int 16 The end of the file offset
binary_format="<17i" #little-endian (<), 17 integers (17i)
#md2 data objects
tex_coords=[]
faces=[]
frames=[]
skins=[]
GL_commands=[]
def __init__ (self):
self.tex_coords=[]
self.faces=[]
self.frames=[]
self.skins=[]
def save(self, file):
temp_data=[0]*17
temp_data[0]=self.ident
temp_data[1]=self.version
temp_data[2]=self.skin_width
temp_data[3]=self.skin_height
temp_data[4]=self.frame_size
temp_data[5]=self.num_skins
temp_data[6]=self.num_vertices
temp_data[7]=self.num_tex_coords
temp_data[8]=self.num_faces
temp_data[9]=self.num_GL_commands
temp_data[10]=self.num_frames
temp_data[11]=self.offset_skins
temp_data[12]=self.offset_tex_coords
temp_data[13]=self.offset_faces
temp_data[14]=self.offset_frames
temp_data[15]=self.offset_GL_commands
temp_data[16]=self.offset_end
data=struct.pack(self.binary_format, temp_data[0],temp_data[1],temp_data[2],temp_data[3],temp_data[4],temp_data[5],temp_data[6],temp_data[7],temp_data[8],temp_data[9],temp_data[10],temp_data[11],temp_data[12],temp_data[13],temp_data[14],temp_data[15],temp_data[16])
file.write(data)
#write the skin data
for skin in self.skins:
skin.save(file)
#save the texture coordinates
for tex_coord in self.tex_coords:
tex_coord.save(file)
#save the face info
for face in self.faces:
face.save(file)
#save the frames
for frame in self.frames:
frame.save(file)
for vert in frame.vertices:
vert.save(file)
#save the GL command List
for cmd in self.GL_commands:
cmd.save(file)
def dump (self):
print "Header Information"
print "ident: ", self.ident
print "version: ", self.version
print "skin width: ", self.skin_width
print "skin height: ", self.skin_height
print "frame size: ", self.frame_size
print "number of skins: ", self.num_skins
print "number of texture coordinates: ", self.num_tex_coords
print "number of faces: ", self.num_faces
print "number of frames: ", self.num_frames
print "number of vertices: ", self.num_vertices
print "number of GL commands: ",self.num_GL_commands
print "offset skins: ", self.offset_skins
print "offset texture coordinates: ", self.offset_tex_coords
print "offset faces: ", self.offset_faces
print "offset frames: ",self.offset_frames
print "offset GL Commands: ",self.offset_GL_commands
print "offset end: ",self.offset_end
print ""
######################################################
# Validation
######################################################
def validation(object):
global user_frame_list
#get access to the mesh data
mesh=object.getData(False, True) #get the object (not just name) and the Mesh, not NMesh
#check it's composed of only tri's
result=0
for face in mesh.faces:
if len(face.verts)!=3:
#select the face for future triangulation
face.sel=1
if result==0: #first time we have this problem, don't pop-up a window every time it finds a quad
print "Model not made entirely of triangles"
result=Blender.Draw.PupMenu("Model not made entirely out of Triangles-Convert?%t|YES|NO")
if result==1:
mesh.quadToTriangle(0) #use closest verticies in breaking a quad
elif result==2:
return False #user will fix (I guess)
#check it has UV coordinates
if mesh.vertexUV==True:
print "Vertex UV not supported"
result=Blender.Draw.PupMenu("Vertex UV not suppored-Use Sticky UV%t|OK")
return False
elif mesh.faceUV==True:
for face in mesh.faces:
if(len(face.uv)==3):
pass
else:
print "Models vertices do not all have UV"
result=Blender.Draw.PupMenu("Models vertices do not all have UV%t|OK")
return False
else:
print "Model does not have UV (face or vertex)"
result=Blender.Draw.PupMenu("Model does not have UV (face or vertex)%t|OK")
return False
#check it has only 1 associated texture map
last_face=""
last_face=mesh.faces[0].image
if last_face=="":
print "Model does not have a texture Map"
result=Blender.Draw.PupMenu("Model does not have a texture Map%t|OK")
return False
for face in mesh.faces:
mesh_image=face.image
if not mesh_image:
print "Model has a face without a texture Map"
result=Blender.Draw.PupMenu("Model has a face without a texture Map%t|OK")
return False
if mesh_image!=last_face:
print "Model has more than 1 texture map assigned"
result=Blender.Draw.PupMenu("Model has more than 1 texture map assigned%t|OK")
return False
size=mesh_image.getSize()
#is this really what the user wants
if (size[0]!=256 or size[1]!=256):
print "Texture map size is non-standard (not 256x256), it is: ",size[0],"x",size[1]
result=Blender.Draw.PupMenu("Texture map size is non-standard (not 256x256), it is: "+size[0]+"x"+size[1]+": Continue?%t|YES|NO")
if(result==2):
return False
#verify frame list data
user_frame_list=get_frame_list()
temp=user_frame_list[len(user_frame_list)-1]
temp_num_frames=temp[2]
#verify tri/vert/frame counts are within MD2 standard
face_count=len(mesh.faces)
vert_count=len(mesh.verts)
frame_count=temp_num_frames
if face_count>MD2_MAX_TRIANGLES:
print "Number of triangles exceeds MD2 standard: ", face_count,">",MD2_MAX_TRIANGLES
result=Blender.Draw.PupMenu("Number of triangles exceeds MD2 standard: Continue?%t|YES|NO")
if(result==2):
return False
if vert_count>MD2_MAX_VERTICES:
print "Number of verticies exceeds MD2 standard",vert_count,">",MD2_MAX_VERTICES
result=Blender.Draw.PupMenu("Number of verticies exceeds MD2 standard: Continue?%t|YES|NO")
if(result==2):
return False
if frame_count>MD2_MAX_FRAMES:
print "Number of frames exceeds MD2 standard of",frame_count,">",MD2_MAX_FRAMES
result=Blender.Draw.PupMenu("Number of frames exceeds MD2 standard: Continue?%t|YES|NO")
if(result==2):
return False
#model is OK
return True
######################################################
# Fill MD2 data structure
######################################################
def fill_md2(md2, object):
global user_frame_list
#get a Mesh, not NMesh
mesh=object.getData(False, True)
#load up some intermediate data structures
tex_list={}
tex_count=0
#create the vertex list from the first frame
Blender.Set("curframe", 1)
#header information
md2.ident=844121161
md2.version=8
md2.num_vertices=len(mesh.verts)
md2.num_faces=len(mesh.faces)
#get the skin information
#use the first faces' image for the texture information
mesh_image=mesh.faces[0].image
size=mesh_image.getSize()
md2.skin_width=size[0]
md2.skin_height=size[1]
md2.num_skins=1
#add a skin node to the md2 data structure
md2.skins.append(md2_skin())
md2.skins[0].name=Blender.sys.basename(mesh_image.getFilename())
#put texture information in the md2 structure
#build UV coord dictionary (prevents double entries-saves space)
for face in mesh.faces:
for i in range(0,3):
t=(face.uv[i])
tex_key=(t[0],t[1])
if not tex_list.has_key(tex_key):
tex_list[tex_key]=tex_count
tex_count+=1
md2.num_tex_coords=tex_count #each vert has its own UV coord
for this_tex in range (0, md2.num_tex_coords):
md2.tex_coords.append(md2_tex_coord())
for coord, index in tex_list.iteritems():
#md2.tex_coords.append(md2_tex_coord())
md2.tex_coords[index].u=int(coord[0]*md2.skin_width)
md2.tex_coords[index].v=int((1-coord[1])*md2.skin_height)
#put faces in the md2 structure
#for each face in the model
for this_face in range(0, md2.num_faces):
md2.faces.append(md2_face())
for i in range(0,3):
#blender uses indexed vertexes so this works very well
md2.faces[this_face].vertex_index[i]=mesh.faces[this_face].verts[i].index
#lookup texture index in dictionary
uv_coord=(mesh.faces[this_face].uv[i])
tex_key=(uv_coord[0],uv_coord[1])
tex_index=tex_list[tex_key]
md2.faces[this_face].texture_index[i]=tex_index
#compute GL commands
md2.num_GL_commands=build_GL_commands(md2)
#get the frame data
#calculate 1 frame size + (1 vert size*num_verts)
md2.frame_size=40+(md2.num_vertices*4) #in bytes
#get the frame list
user_frame_list=get_frame_list()
if user_frame_list=="default":
md2.num_frames=198
else:
temp=user_frame_list[len(user_frame_list)-1] #last item
md2.num_frames=temp[2] #last frame number
#fill in each frame with frame info and all the vertex data for that frame
for frame_counter in range(0,md2.num_frames):
#add a frame
md2.frames.append(md2_frame())
#update the mesh objects vertex positions for the animation
Blender.Set("curframe", frame_counter) #set blender to the correct frame
mesh.getFromObject(object.name) #update the mesh to make verts current
#each frame has a scale and transform value that gets the vertex value between 0-255
#since the scale and transform are the same for the all the verts in the frame, we only need
#to figure this out once per frame
#we need to start with the bounding box
bounding_box=object.getBoundBox() #uses the object, not the mesh data
#initialize with the first vertex for both min and max. X and Y are swapped for MD2 format
point=bounding_box[0]
frame_min_x=point[1]
frame_max_x=point[1]
frame_min_y=point[0]
frame_max_y=point[0]
frame_min_z=point[2]
frame_max_z=point[2]
#find min/max values
for point in bounding_box:
if frame_min_x>point[1]: frame_min_x=point[1]
if frame_max_x<point[1]: frame_max_x=point[1]
if frame_min_y>point[0]: frame_min_y=point[0]
if frame_max_y<point[0]: frame_max_y=point[0]
if frame_min_z>point[2]: frame_min_z=point[2]
if frame_max_z<point[2]: frame_max_z=point[2]
#the scale is the difference between the min and max (on that axis) / 255
frame_scale_x=(frame_max_x-frame_min_x)/255
frame_scale_y=(frame_max_y-frame_min_y)/255
frame_scale_z=(frame_max_z-frame_min_z)/255
#translate value of the mesh to center it on the origin
frame_trans_x=frame_min_x
frame_trans_y=frame_min_y
frame_trans_z=frame_min_z
#fill in the data
md2.frames[frame_counter].scale=(-frame_scale_x, frame_scale_y, frame_scale_z)
md2.frames[frame_counter].translate=(-frame_trans_x, frame_trans_y, frame_trans_z)
#now for the vertices
for vert_counter in range(0, md2.num_vertices):
#add a vertex to the md2 structure
md2.frames[frame_counter].vertices.append(md2_point())
#figure out the new coords based on scale and transform
#then translates the point so it's not less than 0
#then scale it so it's between 0..255
new_x=int((mesh.verts[vert_counter].co[1]-frame_trans_x)/frame_scale_x)
new_y=int((mesh.verts[vert_counter].co[0]-frame_trans_y)/frame_scale_y)
new_z=int((mesh.verts[vert_counter].co[2]-frame_trans_z)/frame_scale_z)
#put them in the structure
md2.frames[frame_counter].vertices[vert_counter].vertices=(new_x, new_y, new_z)
#need to add the lookup table check here
md2.frames[frame_counter].vertices[vert_counter].lightnormalindex=0
#output all the frame names-user_frame_list is loaded during the validation
for frame_set in user_frame_list:
for counter in range(frame_set[1]-1, frame_set[2]):
md2.frames[counter].name=frame_set[0]+"_"+str(counter-frame_set[1]+2)
#compute these after everthing is loaded into a md2 structure
header_size=17*4 #17 integers, and each integer is 4 bytes
skin_size=64*md2.num_skins #64 char per skin * number of skins
tex_coord_size=4*md2.num_tex_coords #2 short * number of texture coords
face_size=12*md2.num_faces #3 shorts for vertex index, 3 shorts for tex index
frames_size=(((12+12+16)+(4*md2.num_vertices)) * md2.num_frames) #frame info+verts per frame*num frames
GL_command_size=md2.num_GL_commands*4 #each is an int or float, so 4 bytes per
#fill in the info about offsets
md2.offset_skins=0+header_size
md2.offset_tex_coords=md2.offset_skins+skin_size
md2.offset_faces=md2.offset_tex_coords+tex_coord_size
md2.offset_frames=md2.offset_faces+face_size
md2.offset_GL_commands=md2.offset_frames+frames_size
md2.offset_end=md2.offset_GL_commands+GL_command_size
######################################################
# Get Frame List
######################################################
def get_frame_list():
global g_frame_filename
frame_list=[]
if g_frame_filename.val=="default":
return MD2_FRAME_NAME_LIST
else:
#check for file
if (Blender.sys.exists(g_frame_filename.val)==1):
#open file and read it in
file=open(g_frame_filename.val,"r")
lines=file.readlines()
file.close()
#check header (first line)
if lines[0]<>"# MD2 Frame Name List\n":
print "its not a valid file"
result=Blender.Draw.PupMenu("This is not a valid frame definition file-using default%t|OK")
return MD2_FRAME_NAME_LIST
else:
#read in the data
num_frames=0
for counter in range(1, len(lines)):
current_line=lines[counter]
if current_line[0]=="#":
#found a comment
pass
else:
data=current_line.split()
frame_list.append([data[0],num_frames+1, num_frames+int(data[1])])
num_frames+=int(data[1])
return frame_list
else:
print "Cannot find file"
result=Blender.Draw.PupMenu("Cannot find frame definion file-using default%t|OK")
return MD2_FRAME_NAME_LIST
######################################################
# Tri-Strip/Tri-Fan functions
######################################################
def find_strip_length(md2, start_tri, start_vert):
#variables shared between fan and strip functions
global used
global strip_vert
global strip_st
global strip_tris
global strip_count
m1=m2=0
st1=st2=0
used[start_tri]=2
last=start_tri
strip_vert[0]=md2.faces[last].vertex_index[start_vert%3]
strip_vert[1]=md2.faces[last].vertex_index[(start_vert+1)%3]
strip_vert[2]=md2.faces[last].vertex_index[(start_vert+2)%3]
strip_st[0]=md2.faces[last].texture_index[start_vert%3]
strip_st[1]=md2.faces[last].texture_index[(start_vert+1)%3]
strip_st[2]=md2.faces[last].texture_index[(start_vert+2)%3]
strip_tris[0]=start_tri
strip_count=1
m1=md2.faces[last].vertex_index[(start_vert+2)%3]
st1=md2.faces[last].texture_index[(start_vert+2)%3]
m2=md2.faces[last].vertex_index[(start_vert+1)%3]
st2=md2.faces[last].texture_index[(start_vert+1)%3]
#look for matching triangle
check=start_tri+1
for tri_counter in range(start_tri+1, md2.num_faces):
for k in range(0,3):
if md2.faces[check].vertex_index[k]!=m1:
continue
if md2.faces[check].texture_index[k]!=st1:
continue
if md2.faces[check].vertex_index[(k+1)%3]!=m2:
continue
if md2.faces[check].texture_index[(k+1)%3]!=st2:
continue
#if we can't use this triangle, this tri_strip is done
if (used[tri_counter]!=0):
for clear_counter in range(start_tri+1, md2.num_faces):
if used[clear_counter]==2:
used[clear_counter]=0
return strip_count
#new edge
if (strip_count & 1):
m2=md2.faces[check].vertex_index[(k+2)%3]
st2=md2.faces[check].texture_index[(k+2)%3]
else:
m1=md2.faces[check].vertex_index[(k+2)%3]
st1=md2.faces[check].texture_index[(k+2)%3]
strip_vert[strip_count+2]=md2.faces[tri_counter].vertex_index[(k+2)%3]
strip_st[strip_count+2]=md2.faces[tri_counter].texture_index[(k+2)%3]
strip_tris[strip_count]=tri_counter
strip_count+=1
used[tri_counter]=2
check+=1
return strip_count
def find_fan_length(md2, start_tri, start_vert):
#variables shared between fan and strip functions
global used
global strip_vert
global strip_st
global strip_tris
global strip_count
m1=m2=0
st1=st2=0
used[start_tri]=2
last=start_tri
strip_vert[0]=md2.faces[last].vertex_index[start_vert%3]
strip_vert[1]=md2.faces[last].vertex_index[(start_vert+1)%3]
strip_vert[2]=md2.faces[last].vertex_index[(start_vert+2)%3]
strip_st[0]=md2.faces[last].texture_index[start_vert%3]
strip_st[1]=md2.faces[last].texture_index[(start_vert+1)%3]
strip_st[2]=md2.faces[last].texture_index[(start_vert+2)%3]
strip_tris[0]=start_tri
strip_count=1
m1=md2.faces[last].vertex_index[(start_vert+0)%3]
st1=md2.faces[last].texture_index[(start_vert+0)%3]
m2=md2.faces[last].vertex_index[(start_vert+2)%3]
st2=md2.faces[last].texture_index[(start_vert+2)%3]
#look for matching triangle
check=start_tri+1
for tri_counter in range(start_tri+1, md2.num_faces):
for k in range(0,3):
if md2.faces[check].vertex_index[k]!=m1:
continue
if md2.faces[check].texture_index[k]!=st1:
continue
if md2.faces[check].vertex_index[(k+1)%3]!=m2:
continue
if md2.faces[check].texture_index[(k+1)%3]!=st2:
continue
#if we can't use this triangle, this tri_strip is done
if (used[tri_counter]!=0):
for clear_counter in range(start_tri+1, md2.num_faces):
if used[clear_counter]==2:
used[clear_counter]=0
return strip_count
#new edge
m2=md2.faces[check].vertex_index[(k+2)%3]
st2=md2.faces[check].texture_index[(k+2)%3]
strip_vert[strip_count+2]=m2
strip_st[strip_count+2]=st2
strip_tris[strip_count]=tri_counter
strip_count+=1
used[tri_counter]=2
check+=1
return strip_count
######################################################
# Globals for GL command list calculations
######################################################
used=[]
strip_vert=0
strip_st=0
strip_tris=0
strip_count=0
######################################################
# Build GL command List
######################################################
def build_GL_commands(md2):
#variables shared between fan and strip functions
global used
used=[0]*md2.num_faces
global strip_vert
strip_vert=[0]*128
global strip_st
strip_st=[0]*128
global strip_tris
strip_tris=[0]*128
global strip_count
strip_count=0
#variables
num_commands=0
start_vert=0
fan_length=strip_length=0
length=best_length=0
best_type=0
best_vert=[0]*1024
best_st=[0]*1024
best_tris=[0]*1024
s=0.0
t=0.0
for face_counter in range(0,md2.num_faces):
if used[face_counter]!=0: #don't evaluate a tri that's been used
#print "found a used triangle: ", face_counter
pass
else:
best_length=0 #restart the counter
#for each vertex index in this face
for start_vert in range(0,3):
fan_length=find_fan_length(md2, face_counter, start_vert)
if (fan_length>best_length):
best_type=1
best_length=fan_length
for index in range (0, best_length+2):
best_st[index]=strip_st[index]
best_vert[index]=strip_vert[index]
for index in range(0, best_length):
best_tris[index]=strip_tris[index]
strip_length=find_strip_length(md2, face_counter, start_vert)
if (strip_length>best_length):
best_type=0
best_length=strip_length
for index in range (0, best_length+2):
best_st[index]=strip_st[index]
best_vert[index]=strip_vert[index]
for index in range(0, best_length):
best_tris[index]=strip_tris[index]
#mark the tris on the best strip/fan as used
for used_counter in range (0, best_length):
used[best_tris[used_counter]]=1
temp_cmdlist=md2_GL_cmd_list()
#push the number of commands into the command stream
if best_type==1:
temp_cmdlist.num=best_length+2
num_commands+=1
else:
temp_cmdlist.num=(-(best_length+2))
num_commands+=1
for command_counter in range (0, best_length+2):
#emit a vertex into the reorder buffer
cmd=md2_GL_command()
index=best_st[command_counter]
#calc and put S/T coords in the structure
s=md2.tex_coords[index].u
t=md2.tex_coords[index].v
s=(s+0.5)/md2.skin_width
t=(t+0.5)/md2.skin_height
cmd.s=s
cmd.t=t
cmd.vert_index=best_vert[command_counter]
temp_cmdlist.cmd_list.append(cmd)
num_commands+=3
md2.GL_commands.append(temp_cmdlist)
#end of list
temp_cmdlist=md2_GL_cmd_list()
temp_cmdlist.num=0
md2.GL_commands.append(temp_cmdlist)
num_commands+=1
#cleanup and return
used=best_vert=best_st=best_tris=strip_vert=strip_st=strip_tris=0
return num_commands
######################################################
# Save MD2 Format
######################################################
def save_md2(filename):
md2=md2_obj() #blank md2 object to save
#get the object
mesh_objs = Blender.Object.GetSelected()
#check there is a blender object selected
if len(mesh_objs)==0:
print "Fatal Error: Must select a mesh to output as MD2"
print "Found nothing"
result=Blender.Draw.PupMenu("Must select an object to export%t|OK")
return
mesh_obj=mesh_objs[0] #this gets the first object (should be only one)
#check if it's a mesh object
if mesh_obj.getType()!="Mesh":
print "Fatal Error: Must select a mesh to output as MD2"
print "Found: ", mesh_obj.getType()
result=Blender.Draw.PupMenu("Selected Object must be a mesh to output as MD2%t|OK")
return
ok=validation(mesh_obj)
if ok==False:
return
fill_md2(md2, mesh_obj)
md2.dump()
#actually write it to disk
file=open(filename,"wb")
md2.save(file)
file.close()
#cleanup
md2=0
print "Closed the file"