601 lines
18 KiB
Python
601 lines
18 KiB
Python
#!BPY
|
|
|
|
"""
|
|
Name: 'MD2 (.md2)'
|
|
Blender: 239
|
|
Group: 'Import'
|
|
Tooltip: 'Import from 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", "blenderartists.org"]
|
|
__email__ = ["Bob Holcomb, bob_holcomb:hotmail*com", "scripts"]
|
|
__bpydoc__ = """\
|
|
This script imports a Quake 2 file (MD2), textures,
|
|
and animations into blender for editing. Loader is based on MD2 loader from www.gametutorials.com-Thanks DigiBen! and the md3 blender loader by PhaethonH <phaethon@linux.ucla.edu><br>
|
|
|
|
Additional help from: Shadwolf, Skandal, Rojo and Campbell Barton<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 Mesh, Object, sys
|
|
from Blender.BGL import *
|
|
from Blender.Draw import *
|
|
from Blender.Window import *
|
|
from Blender.Mathutils import Vector
|
|
import struct
|
|
from types import *
|
|
|
|
|
|
######################################################
|
|
# Main Body
|
|
######################################################
|
|
|
|
#returns the string from a null terminated string
|
|
def asciiz (s):
|
|
n = 0
|
|
while (ord(s[n]) != 0):
|
|
n = n + 1
|
|
return s[0:n]
|
|
|
|
|
|
######################################################
|
|
# 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 data structures
|
|
######################################################
|
|
class md2_alias_triangle(object):
|
|
__slots__ = 'vertices', 'lightnormalindex'
|
|
binary_format="<3BB" #little-endian (<), 3 Unsigned char
|
|
|
|
def __init__(self):
|
|
self.vertices=[0]*3
|
|
self.lightnormalindex=0
|
|
|
|
def load(self, file):
|
|
temp_data = file.read(struct.calcsize(self.binary_format))
|
|
data = struct.unpack(self.binary_format, temp_data)
|
|
self.vertices[0]=data[0]
|
|
self.vertices[1]=data[1]
|
|
self.vertices[2]=data[2]
|
|
self.lightnormalindex=data[3]
|
|
return self
|
|
|
|
def dump(self):
|
|
print "MD2 Alias_Triangle Structure"
|
|
print "vertex: ", self.vertices[0]
|
|
print "vertex: ", self.vertices[1]
|
|
print "vertex: ", self.vertices[2]
|
|
print "lightnormalindex: ",self.lightnormalindex
|
|
print ""
|
|
|
|
class md2_face(object):
|
|
|
|
binary_format="<3h3h" #little-endian (<), 3 short, 3 short
|
|
|
|
__slots__ = 'vertex_index', 'texture_index'
|
|
|
|
def __init__(self):
|
|
self.vertex_index = [ 0, 0, 0 ]
|
|
self.texture_index = [ 0, 0, 0]
|
|
|
|
def load (self, file):
|
|
temp_data=file.read(struct.calcsize(self.binary_format))
|
|
data=struct.unpack(self.binary_format, temp_data)
|
|
self.vertex_index[0]=data[0]
|
|
self.vertex_index[1]=data[1]
|
|
self.vertex_index[2]=data[2]
|
|
self.texture_index[0]=data[3]
|
|
self.texture_index[1]=data[4]
|
|
self.texture_index[2]=data[5]
|
|
return self
|
|
|
|
def dump (self):
|
|
print "MD2 Face Structure"
|
|
print "vertex index: ", self.vertex_index[0]
|
|
print "vertex index: ", self.vertex_index[1]
|
|
print "vertex index: ", self.vertex_index[2]
|
|
print "texture index: ", self.texture_index[0]
|
|
print "texture index: ", self.texture_index[1]
|
|
print "texture index: ", self.texture_index[2]
|
|
print ""
|
|
|
|
class md2_tex_coord(object):
|
|
__slots__ = 'u', 'v'
|
|
binary_format="<2h" #little-endian (<), 2 unsigned short
|
|
|
|
def __init__(self):
|
|
self.u=0
|
|
self.v=0
|
|
|
|
def load (self, file):
|
|
temp_data=file.read(struct.calcsize(self.binary_format))
|
|
data=struct.unpack(self.binary_format, temp_data)
|
|
self.u=data[0]
|
|
self.v=data[1]
|
|
return self
|
|
|
|
def dump (self):
|
|
print "MD2 Texture Coordinate Structure"
|
|
print "texture coordinate u: ",self.u
|
|
print "texture coordinate v: ",self.v
|
|
print ""
|
|
|
|
|
|
class md2_skin(object):
|
|
__slots__ = 'name'
|
|
binary_format="<64s" #little-endian (<), char[64]
|
|
|
|
def __init__(self):
|
|
self.name=""
|
|
|
|
def load (self, file):
|
|
temp_data=file.read(struct.calcsize(self.binary_format))
|
|
data=struct.unpack(self.binary_format, temp_data)
|
|
self.name=asciiz(data[0])
|
|
return self
|
|
|
|
def dump (self):
|
|
print "MD2 Skin"
|
|
print "skin name: ",self.name
|
|
print ""
|
|
|
|
class md2_alias_frame(object):
|
|
__slots__ = 'scale', 'translate', 'name', 'vertices'
|
|
binary_format="<3f3f16s" #little-endian (<), 3 float, 3 float char[16]
|
|
#did not add the "3bb" to the end of the binary format
|
|
#because the alias_vertices will be read in through
|
|
#thier own loader
|
|
|
|
def __init__(self):
|
|
self.scale=[0.0]*3
|
|
self.translate=[0.0]*3
|
|
self.name=""
|
|
self.vertices=[]
|
|
|
|
|
|
def load (self, file):
|
|
temp_data=file.read(struct.calcsize(self.binary_format))
|
|
data=struct.unpack(self.binary_format, temp_data)
|
|
self.scale[0]=data[0]
|
|
self.scale[1]=data[1]
|
|
self.scale[2]=data[2]
|
|
self.translate[0]=data[3]
|
|
self.translate[1]=data[4]
|
|
self.translate[2]=data[5]
|
|
self.name=asciiz(data[6])
|
|
return self
|
|
|
|
def dump (self):
|
|
print "MD2 Alias 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(object):
|
|
__slots__ =\
|
|
'tex_coords', 'faces', 'frames',\
|
|
'skins', 'ident', 'version',\
|
|
'skin_width', 'skin_height',\
|
|
'frame_size', 'num_skins', 'num_vertices',\
|
|
'num_tex_coords', 'num_faces', 'num_GL_commands',\
|
|
'num_frames', 'offset_skins', 'offset_tex_coords',\
|
|
'offset_faces', 'offset_frames', 'offset_GL_commands'
|
|
|
|
'''
|
|
#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
|
|
|
|
def __init__ (self):
|
|
self.tex_coords=[]
|
|
self.faces=[]
|
|
self.frames=[]
|
|
self.skins=[]
|
|
|
|
|
|
def load (self, file):
|
|
temp_data = file.read(struct.calcsize(self.binary_format))
|
|
data = struct.unpack(self.binary_format, temp_data)
|
|
|
|
self.ident=data[0]
|
|
self.version=data[1]
|
|
|
|
if (self.ident!=844121161 or self.version!=8):
|
|
print "Not a valid MD2 file"
|
|
Exit()
|
|
|
|
self.skin_width=data[2]
|
|
self.skin_height=data[3]
|
|
self.frame_size=data[4]
|
|
|
|
#make the # of skin objects for model
|
|
self.num_skins=data[5]
|
|
for i in xrange(0,self.num_skins):
|
|
self.skins.append(md2_skin())
|
|
|
|
self.num_vertices=data[6]
|
|
|
|
#make the # of texture coordinates for model
|
|
self.num_tex_coords=data[7]
|
|
for i in xrange(0,self.num_tex_coords):
|
|
self.tex_coords.append(md2_tex_coord())
|
|
|
|
#make the # of triangle faces for model
|
|
self.num_faces=data[8]
|
|
for i in xrange(0,self.num_faces):
|
|
self.faces.append(md2_face())
|
|
|
|
self.num_GL_commands=data[9]
|
|
|
|
#make the # of frames for the model
|
|
self.num_frames=data[10]
|
|
for i in xrange(0,self.num_frames):
|
|
self.frames.append(md2_alias_frame())
|
|
#make the # of vertices for each frame
|
|
for j in xrange(0,self.num_vertices):
|
|
self.frames[i].vertices.append(md2_alias_triangle())
|
|
|
|
self.offset_skins=data[11]
|
|
self.offset_tex_coords=data[12]
|
|
self.offset_faces=data[13]
|
|
self.offset_frames=data[14]
|
|
self.offset_GL_commands=data[15]
|
|
|
|
#load the skin info
|
|
file.seek(self.offset_skins,0)
|
|
for i in xrange(0, self.num_skins):
|
|
self.skins[i].load(file)
|
|
#self.skins[i].dump()
|
|
|
|
#load the texture coordinates
|
|
file.seek(self.offset_tex_coords,0)
|
|
for i in xrange(0, self.num_tex_coords):
|
|
self.tex_coords[i].load(file)
|
|
#self.tex_coords[i].dump()
|
|
|
|
#load the face info
|
|
file.seek(self.offset_faces,0)
|
|
for i in xrange(0, self.num_faces):
|
|
self.faces[i].load(file)
|
|
#self.faces[i].dump()
|
|
|
|
#load the frames
|
|
file.seek(self.offset_frames,0)
|
|
for i in xrange(0, self.num_frames):
|
|
self.frames[i].load(file)
|
|
#self.frames[i].dump()
|
|
for j in xrange(0,self.num_vertices):
|
|
self.frames[i].vertices[j].load(file)
|
|
#self.frames[i].vertices[j].dump()
|
|
return self
|
|
|
|
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 "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 ""
|
|
|
|
######################################################
|
|
# Import functions
|
|
######################################################
|
|
def load_textures(md2, texture_filename):
|
|
#did the user specify a texture they wanted to use?
|
|
if texture_filename:
|
|
if (Blender.sys.exists(texture_filename)):
|
|
try: return Blender.Image.Load(texture_filename)
|
|
except: return -1 # could not load?
|
|
|
|
#does the model have textures specified with it?
|
|
if int(md2.num_skins) > 0:
|
|
for i in xrange(0,md2.num_skins):
|
|
#md2.skins[i].dump()
|
|
if (Blender.sys.exists(md2.skins[i].name)):
|
|
try: return Blender.Image.Load(md2.skins[i].name)
|
|
except: return -1
|
|
|
|
|
|
def animate_md2(md2, mesh):
|
|
######### Animate the verts through keyframe animation
|
|
|
|
# Fast access to the meshes vertex coords
|
|
verts = [v.co for v in mesh.verts]
|
|
scale = g_scale.val
|
|
|
|
for i in xrange(1, md2.num_frames):
|
|
frame = md2.frames[i]
|
|
#update the vertices
|
|
for j in xrange(md2.num_vertices):
|
|
x=(frame.scale[0] * frame.vertices[j].vertices[0] + frame.translate[0]) * scale
|
|
y=(frame.scale[1] * frame.vertices[j].vertices[1] + frame.translate[1]) * scale
|
|
z=(frame.scale[2] * frame.vertices[j].vertices[2] + frame.translate[2]) * scale
|
|
|
|
#put the vertex in the right spot
|
|
verts[j][:] = y,-x,z
|
|
|
|
mesh.insertKey(i,"absolute")
|
|
# mesh.insertKey(i)
|
|
|
|
#not really necissary, but I like playing with the frame counter
|
|
Blender.Set("curframe", i)
|
|
|
|
|
|
# Make the keys animate in the 3d view.
|
|
key = mesh.key
|
|
key.relative = False
|
|
|
|
# Add an IPO to teh Key
|
|
ipo = Blender.Ipo.New('Key', 'md2')
|
|
key.ipo = ipo
|
|
# Add a curve to the IPO
|
|
curve = ipo.addCurve('Basis')
|
|
|
|
# Add 2 points to cycle through the frames.
|
|
curve.append((1, 0))
|
|
curve.append((md2.num_frames, (md2.num_frames-1)/10.0))
|
|
curve.interpolation = Blender.IpoCurve.InterpTypes.LINEAR
|
|
|
|
|
|
|
|
def load_md2(md2_filename, texture_filename):
|
|
#read the file in
|
|
file=open(md2_filename,"rb")
|
|
WaitCursor(1)
|
|
DrawProgressBar(0.0, 'Loading MD2')
|
|
md2=md2_obj()
|
|
md2.load(file)
|
|
#md2.dump()
|
|
file.close()
|
|
|
|
######### Creates a new mesh
|
|
mesh = Mesh.New()
|
|
|
|
uv_coord=[]
|
|
#uv_list=[]
|
|
verts_extend = []
|
|
#load the textures to use later
|
|
#-1 if there is no texture to load
|
|
mesh_image=load_textures(md2, texture_filename)
|
|
if mesh_image == -1 and texture_filename:
|
|
print 'MD2 Import, Warning, texture "%s" could not load'
|
|
|
|
######### Make the verts
|
|
DrawProgressBar(0.25,"Loading Vertex Data")
|
|
frame = md2.frames[0]
|
|
scale = g_scale.val
|
|
|
|
def tmp_get_vertex(i):
|
|
#use the first frame for the mesh vertices
|
|
x=(frame.scale[0]*frame.vertices[i].vertices[0]+frame.translate[0])*scale
|
|
y=(frame.scale[1]*frame.vertices[i].vertices[1]+frame.translate[1])*scale
|
|
z=(frame.scale[2]*frame.vertices[i].vertices[2]+frame.translate[2])*scale
|
|
return y,-x,z
|
|
|
|
mesh.verts.extend( [tmp_get_vertex(i) for i in xrange(0,md2.num_vertices)] )
|
|
del tmp_get_vertex
|
|
|
|
######## Make the UV list
|
|
DrawProgressBar(0.50,"Loading UV Data")
|
|
|
|
w = float(md2.skin_width)
|
|
h = float(md2.skin_height)
|
|
if w <= 0.0: w = 1.0
|
|
if h <= 0.0: h = 1.0
|
|
#for some reason quake2 texture maps are upside down, flip that
|
|
uv_list = [Vector(co.u/w, 1-(co.v/h)) for co in md2.tex_coords]
|
|
del w, h
|
|
|
|
######### Make the faces
|
|
DrawProgressBar(0.75,"Loading Face Data")
|
|
faces = []
|
|
face_uvs = []
|
|
for md2_face in md2.faces:
|
|
f = md2_face.vertex_index[0], md2_face.vertex_index[2], md2_face.vertex_index[1]
|
|
uv = uv_list[md2_face.texture_index[0]], uv_list[md2_face.texture_index[2]], uv_list[md2_face.texture_index[1]]
|
|
|
|
if f[2] == 0:
|
|
# EEKADOODLE :/
|
|
f= f[1], f[2], f[0]
|
|
uv= uv[1], uv[2], uv[0]
|
|
|
|
#ditto in reverse order with the texture verts
|
|
faces.append(f)
|
|
face_uvs.append(uv)
|
|
|
|
|
|
face_mapping = mesh.faces.extend(faces, indexList=True)
|
|
print len(faces)
|
|
print len(mesh.faces)
|
|
mesh.faceUV= True #turn on face UV coordinates for this mesh
|
|
mesh_faces = mesh.faces
|
|
for i, uv in enumerate(face_uvs):
|
|
if face_mapping[i] != None:
|
|
f = mesh_faces[face_mapping[i]]
|
|
f.uv = uv
|
|
if (mesh_image!=-1):
|
|
f.image=mesh_image
|
|
|
|
scn= Blender.Scene.GetCurrent()
|
|
mesh_obj= scn.objects.new(mesh)
|
|
animate_md2(md2, mesh)
|
|
DrawProgressBar(0.98,"Loading Animation Data")
|
|
|
|
#locate the Object containing the mesh at the cursor location
|
|
cursor_pos=Blender.Window.GetCursorPos()
|
|
mesh_obj.setLocation(float(cursor_pos[0]),float(cursor_pos[1]),float(cursor_pos[2]))
|
|
DrawProgressBar (1.0, "")
|
|
WaitCursor(0)
|
|
|
|
#***********************************************
|
|
# MAIN
|
|
#***********************************************
|
|
|
|
# Import globals
|
|
g_md2_filename=Create("*.md2")
|
|
#g_md2_filename=Create("/d/warvet/tris.md2")
|
|
g_texture_filename=Create('')
|
|
# g_texture_filename=Create("/d/warvet/warvet.jpg")
|
|
|
|
g_filename_search=Create("*.md2")
|
|
g_texture_search=Create('')
|
|
# g_texture_search=Create("/d/warvet/warvet.jpg")
|
|
|
|
#Globals
|
|
g_scale=Create(1.0)
|
|
|
|
# Events
|
|
EVENT_NOEVENT=1
|
|
EVENT_LOAD_MD2=2
|
|
EVENT_CHOOSE_FILENAME=3
|
|
EVENT_CHOOSE_TEXTURE=4
|
|
EVENT_SAVE_MD2=5
|
|
EVENT_EXIT=100
|
|
|
|
######################################################
|
|
# Callbacks for Window functions
|
|
######################################################
|
|
def filename_callback(input_filename):
|
|
global g_md2_filename
|
|
g_md2_filename.val=input_filename
|
|
|
|
def texture_callback(input_texture):
|
|
global g_texture_filename
|
|
g_texture_filename.val=input_texture
|
|
|
|
######################################################
|
|
# GUI Loader
|
|
######################################################
|
|
|
|
|
|
def draw_gui():
|
|
global g_scale
|
|
global g_md2_filename
|
|
global g_texture_filename
|
|
global EVENT_NOEVENT,EVENT_LOAD_MD2,EVENT_CHOOSE_FILENAME,EVENT_CHOOSE_TEXTURE,EVENT_EXIT
|
|
|
|
########## Titles
|
|
glClear(GL_COLOR_BUFFER_BIT)
|
|
glRasterPos2d(8, 125)
|
|
Text("MD2 loader")
|
|
|
|
######### Parameters GUI Buttons
|
|
BeginAlign()
|
|
g_md2_filename = String("MD2 file to load: ", EVENT_NOEVENT, 10, 55, 210, 18,
|
|
g_md2_filename.val, 255, "MD2 file to load")
|
|
########## MD2 File Search Button
|
|
Button("Browse",EVENT_CHOOSE_FILENAME,220,55,80,18)
|
|
EndAlign()
|
|
|
|
BeginAlign()
|
|
g_texture_filename = String("Texture file to load: ", EVENT_NOEVENT, 10, 35, 210, 18,
|
|
g_texture_filename.val, 255, "Texture file to load-overrides MD2 file")
|
|
########## Texture Search Button
|
|
Button("Browse",EVENT_CHOOSE_TEXTURE,220,35,80,18)
|
|
EndAlign()
|
|
|
|
########## 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("Load",EVENT_LOAD_MD2 , 10, 10, 80, 18)
|
|
Button("Exit",EVENT_EXIT , 170, 10, 80, 18)
|
|
|
|
def event(evt, val):
|
|
if (evt == QKEY and not val):
|
|
Blender.Draw.Exit()
|
|
|
|
def bevent(evt):
|
|
global g_md2_filename
|
|
global g_texture_filename
|
|
global EVENT_NOEVENT,EVENT_LOAD_MD2,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_TEXTURE):
|
|
FileSelector(texture_callback, "Texture Selection")
|
|
elif (evt==EVENT_LOAD_MD2):
|
|
if not Blender.sys.exists(g_md2_filename.val):
|
|
PupMenu('Model file does not exist')
|
|
return
|
|
else:
|
|
load_md2(g_md2_filename.val, g_texture_filename.val)
|
|
Blender.Redraw()
|
|
Blender.Draw.Exit()
|
|
return
|
|
|
|
if __name__ == '__main__':
|
|
Register(draw_gui, event, bevent)
|