MD2 export problem

The interface, modeling, 3d editing tools, import/export, feature requests, etc

Moderators: jesterKing, stiv

Post Reply
Hoehrer
Posts: 0
Joined: Wed Nov 02, 2005 12:36 pm

MD2 export problem

Post by Hoehrer » Fri Feb 24, 2006 5:29 pm

I'm trying to export a mesh from blender to the md2 format, but i always get the error message

Code: Select all

...
Model has a face without a texture Map
in the end, no matter what i do. All my faces are uv-mapped. If there is anything unmapped i sure can't find it :-/ Does anybody know what to do here?

EDIT: homepage issue solved
The page http://bane.servebeer.com/programming/b ... index.html seem to be down, so i can't even check if there is a newer version of the script.
EDIT: Small update.. i found that http://70.174.118.233:8082/programming/blender/ is working, but the script there is exactly the same version as the one included in blender.


Werner
Last edited by Hoehrer on Thu Mar 23, 2006 8:29 am, edited 1 time in total.

Hoehrer
Posts: 0
Joined: Wed Nov 02, 2005 12:36 pm

test case

Post by Hoehrer » Tue Feb 28, 2006 12:41 pm

Ok, here's a small test case to show that it doesn't work (for me at least). Import works fine though.

* Start a new blend-file with the default cube.
* Create a UV-map - just use the 'cube' mapping (EDIT: "UV Calculation -> Cube").. UV-algorithm you choose doesn't really matter in this test-case.
* Add a new texture ("Texture type: image") to the material and load any image-file.
* EDIT: Set the texture to UV-mapping ("Map Input -> UV")
* "Export"->"MD2"
* Error "Model has a face without a texture Map"

I might be missing somehting, but i doubt it.

Werner

EDIT: made it a bit clearer
Last edited by Hoehrer on Fri Mar 31, 2006 8:50 am, edited 2 times in total.

scourage
Posts: 0
Joined: Wed Jan 07, 2004 12:54 pm

Post by scourage » Thu Mar 02, 2006 5:39 pm

My site is down for now because I'm in the middle of a move, but I'll look into the script and see why it's not working for you.

cheers,

bob
Halfway down the trail to hell....

Hoehrer
Posts: 0
Joined: Wed Nov 02, 2005 12:36 pm

Post by Hoehrer » Fri Mar 03, 2006 11:50 am

Yes, I found that out recently. Thanks for looking into this, it is much appreciated...especially since the game i'm trying to model for [1] uses a modified Q2 engineand thus the md2 format :)

Werner

[1] UFO: Alien Invasion

3dmaniak
Posts: 0
Joined: Sat Mar 04, 2006 9:36 pm

Post by 3dmaniak » Tue Mar 07, 2006 2:15 pm

Hi,
I also have aprobleme with MD2 export.
First I had a message saing that there was no UV mapping, but I used UV texture so now I dont have this message. But I have an error msg "can not concatenate string with long values".

Do you know if this error is caused by script or I did something wrong?

Hoehrer
Posts: 0
Joined: Wed Nov 02, 2005 12:36 pm

Post by Hoehrer » Thu Mar 09, 2006 9:12 am

Just FYI: I've added a MD2 entry in the blender-wiki:
http://mediawiki.blender.org/index.php/MD2

Werner

Hoehrer
Posts: 0
Joined: Wed Nov 02, 2005 12:36 pm

Post by Hoehrer » Mon Mar 20, 2006 11:56 am

@scourage: Is there any news on the md2 script?


EDIT: Started to debug the md2-export script ... or at least i try that: http://www.blender.org/forum/viewtopic. ... 1236#51236

Werner

adenau
Posts: 0
Joined: Tue Mar 28, 2006 3:31 pm

M2D export

Post by adenau » Tue Mar 28, 2006 3:37 pm

I am also having problems with the MD2 export. At first, I was having the same problem (model has a face without a texture map). However, I discovered that the exporter will not work until you have assign an image to each of your UV map. That's one problem solved.

I was able to export one of my animated drawing to a md2 file However, when I load it into Xith3D, it shows up as garbage. Is it possible that the exporter is not producing a valid md2 file? I tried importing my md2 export back into blender and it also loaded up as garbage.

Hoehrer
Posts: 0
Joined: Wed Nov 02, 2005 12:36 pm

Re: M2D export

Post by Hoehrer » Tue Mar 28, 2006 4:07 pm

adenau wrote:I am also having problems with the MD2 export. At first, I was having the same problem (model has a face without a texture map). However, I discovered that the exporter will not work until you have assign an image to each of your UV map. That's one problem solved.
I can't even get past this problem (see my test-caste from the second post on the top of the thread).
I was able to export one of my animated drawing to a md2 file However, when I load it into Xith3D, it shows up as garbage. Is it possible that the exporter is not producing a valid md2 file? I tried importing my md2 export back into blender and it also loaded up as garbage.
md2-import works fine for me (no animations tested though), so i believe only the export is messed up a bit.

Werner

adenau
Posts: 0
Joined: Tue Mar 28, 2006 3:31 pm

Re: test case

Post by adenau » Thu Mar 30, 2006 4:10 am

Hoehrer wrote: * Add a new texture ("image") to the material and load any image-file.
When the export complains about a missing texture on a face, it doesn't talk about materials as they are handled in Blender. When you create a UV map, you can load an image into this UV map. You must load an image for each uv map you create for the export to work.

Hoehrer
Posts: 0
Joined: Wed Nov 02, 2005 12:36 pm

Re: test case

Post by Hoehrer » Thu Mar 30, 2006 4:18 pm

adenau wrote:
Hoehrer wrote: * Add a new texture ("image") to the material and load any image-file.
When the export complains about a missing texture on a face, it doesn't talk about materials as they are handled in Blender. When you create a UV map, you can load an image into this UV map. You must load an image for each uv map you create for the export to work.
I did create an UV map ("UV Calculation -> Cube" before that (didn't write that clearly) ...
*Create a UV-map (just use the 'cube' mapping.. doesn't really matter).
... so the only missing thing is the image. In my test case i try using a "Texture type: image"-material (loading the image file from HD) and assign it to "UV".

When you say "load" where do you mean to load it? Or what else am i doing wrong? I do know how blender handles uv-maps/images, but if the script doesn't take them where else does it get the info?

Werner

scourage
Posts: 0
Joined: Wed Jan 07, 2004 12:54 pm

Post by scourage » Thu Mar 30, 2006 8:41 pm

I'm working on the exporter a little right now and I've noticed some unusual behavior. the Mesh.quadToTriangle function requires the mesh to be in face mode. Otherwise the function returns and carries on like it did convert, but the mesh is not affected.

I don't think this is the intended behavior. Campbell do you know?

cheers,

Bob
Halfway down the trail to hell....

scourage
Posts: 0
Joined: Wed Jan 07, 2004 12:54 pm

Post by scourage » Thu Mar 30, 2006 8:58 pm

Give this version a try. I won't be able to upload it to my server for a while. I hope the BB does'nt mess up the whitespace

cheers,

Bob

Code: Select all

#!BPY

"""
Name: 'MD2 (.md2)'
Blender: 239
Group: 'Export'
Tooltip: 'Export to Quake file format (.md2).'
"""

__author__ = 'Bob Holcomb'
__version__ = '0.16.1'
__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")
	
	print "result: ", result
	#triangulate or quit
	if result==1:
		#selecting face mode
		Blender.Mesh.Mode(3)
		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: "+str(size[0])+"x"+str(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"
Halfway down the trail to hell....

Hoehrer
Posts: 0
Joined: Wed Nov 02, 2005 12:36 pm

Post by Hoehrer » Fri Mar 31, 2006 8:44 am

I got one error in the script, because there's one space too much:

Code: Select all

   ######### Draw and Exit Buttons 
   Button("Export",EVENT_SAVE_MD2 , 10, 10, 80, 18) 
    Button("Exit",EVENT_EXIT , 170, 10, 80, 18) 
I've fixed it and tried to export the test-cube with an uv-map again, but i just get the error:

Code: Select all

Model has a face without a texture Map
And if i try exporting a finished model of mine (that exports fine to e.g ".obj") i get:

Code: Select all

...
Model not made entirely of triangles
result:  1
Traceback (most recent call last):
  File "<string>", line 141, in bevent
  File "<string>", line 1006, in save_md2
  File "<string>", line 504, in validation
RuntimeError: couldn't load image data in Blender
I can send you the model if you want (just pm me your mail).

Werner

scourage
Posts: 0
Joined: Wed Jan 07, 2004 12:54 pm

Post by scourage » Fri Mar 31, 2006 5:35 pm

It's not just that there needs to be UV mapping on the cube, but you have to have a texture loaded and applied to the model. I'd like to see your model. PM is disabled on this board, send it to me at bob_holcomb 'at' hotmail 'dot' com.

Cheers,

Bob
Halfway down the trail to hell....

Post Reply