Md2 File animation

[shadow008]

So here's what ive been doing for animation:


'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Data types

struc SMD2_header
   
   ' File information
   dim ident
   dim version
   dim skinwidth                   ' Width of skin texture (pixels)
   dim skinheight                  ' Height of skin texture (pixels)
   dim framesize                  
   
   ' Number of different components
   dim num_skins                   ' Skins
   dim num_xyz                     ' Vertices (x, y, z)
   dim num_st                      ' Texture coordinates (s, t)
   dim num_tris                    ' Triangles
   dim num_glcmds                  ' GL Commands (which we aren't going to use)
   dim num_frames                  ' Frames
   
   ' File offset of different components
   dim ofs_skins                   ' Skins
   dim ofs_st                      ' Texture coordinates (s,t)
   dim ofs_tris                    ' Triangles
   dim ofs_frames                  ' Frames
   dim ofs_glcmds                  ' GL Commands (which we aren't going to use)
   dim ofs_end                     ' End of file
endstruc

struc SMD2_vertex
   dim v#(2)                                   ' Vertex
   dim normal as single                                 ' Index of normal (into some lookup table. I can't find any info on this table, so normals and lighting aren't currently implemented.)
endstruc

struc SMD2_triangle
   dim index_xyz(2)                            ' Index of triangle vertices
   dim index_st(2)                             ' Index of texture coordinates
endstruc

struc SMD2_frame
   dim scale#(2), translate#(2)                ' Scaling and translation
   dim name$                                   ' Display name
   dim SMD2_vertex &verts()                    ' Vertices
endstruc

type MD2_Model
   dim SMD2_header header                      ' Header data
   dim &skins ()                               ' Skin textures
   dim &st# ()()                               ' Texture coordinates (compressed)
   dim SMD2_triangle &tris ()                  ' Triangles
   dim SMD2_frame &frames()                    ' Frames
   dim CurrentFrame as single
   dim SMD2_frame theFrame2
   dim SMD2_frame theFrame          
   dim frameNum
   dim frameNum2
   dim fileDir as string
   dim filefolder as string
   dim theFile as single
   dim pos(2) as single
   dim rot(2) as single
   dim scale(2) as single
   dim prefirst
   dim prelast
   dim interp
   dim hold
   dim first
   dim still
end type

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Functions

''''''''''''''''''''''
' Internal functions
function LoadMD2Header(&theHeader as SMD2_header, theFile)
   
   ' Expects:
   '   &theHeader = points to the destination header data
   '   file       = file handle to read from
   theHeader.ident       = ReadInt (theFile)
   theHeader.version     = ReadInt (theFile)
   theHeader.skinwidth   = ReadInt (theFile)
   theHeader.skinheight  = ReadInt (theFile)
   theHeader.framesize   = ReadInt (theFile)
   theHeader.num_skins   = ReadInt (theFile)
   theHeader.num_xyz     = ReadInt (theFile)
   theHeader.num_st      = ReadInt (theFile)
   theHeader.num_tris    = ReadInt (theFile)
   theHeader.num_glcmds  = ReadInt (theFile)
   theHeader.num_frames  = ReadInt (theFile)
   theHeader.ofs_skins   = ReadInt (theFile)
   theHeader.ofs_st      = ReadInt (theFile)
   theHeader.ofs_tris    = ReadInt (theFile)
   theHeader.ofs_frames  = ReadInt (theFile)
   theHeader.ofs_glcmds  = ReadInt (theFile)
   theHeader.ofs_end     = ReadInt (theFile)

   return 0

endfunction
   
function LoadMD2Skins(&theModel as MD2_Model, theFile)

   ' Expects:
   '   &theModel  = points to the destination model
   '   file       = file handle to read from
   
   ' Seek to skin texture names
   Seek (theFile, theModel.header.ofs_skins)
   
   dim tempStr$, i2

   ' Allocate skin texture handles
   alloc theModel.skins, theModel.header.num_skins - 1
   
   ' Load textures
   for i = 0 to theModel.header.num_skins - 1
   
       ' Read texture name
       tempStr$ = ""
       for i2 = 1 to 64: tempStr$ = tempStr$ + ReadChar (theFile): next    ' Read name
       while Len (tempStr$) > 0 and Right$ (tempStr$, 1) <= " "            ' Trim whitespace from right
           tempStr$ = Left$ (tempStr$, Len (tempStr$) - 1)
       wend

       ' Load texture
       theModel.skins (i) = LoadMipmapTexture (theModel.FileFolder + tempStr$)
       if theModel.skins (i) <= 0 then
           print "Failed to load texture: " + tempStr$
       endif  
   next
             
   return 0
         
endfunction
   
function LoadMD2ST(&theModel as MD2_Model, theFile)
   
   ' Expects:
   '   &theModel  = points to the destination model
   '   file       = file handle to read from
   
   ' Allocate texture coordinates    
   alloc theModel.st#, theModel.header.num_st - 1, 1
   
   ' Seek to texture coordinates
   Seek (theFile, theModel.header.ofs_st)

   ' Load texture coordinates
   for i = 0 to theModel.header.num_st - 1
       theModel.st# (i)(0) = ReadWord (theFile)
       theModel.st# (i)(1) = ReadWord (theFile)
   next
   
   return 0

endfunction
   
function LoadMD2Tris(&theModel as MD2_Model, theFile)

   ' Expects:
   '   &theModel  = points to the destination model
   '   file       = file handle to read from
   
   ' Allocate triangles
   alloc theModel.tris, theModel.header.num_tris - 1
   
   ' Seek to triangles
   Seek (theFile, theModel.header.ofs_tris)
   dim i2
   ' Load triangles
   for i = 0 to theModel.header.num_tris - 1
       for i2 = 0 to 2
           theModel.tris (i).index_xyz (i2) = ReadWord (theFile)
       next
       for i2 = 0 to 2
           theModel.tris (i).index_st (i2) = ReadWord (theFile)
       next
   next
   
   return 0

endfunction
   
function LoadMD2Frames(&theModel as MD2_Model, theFile)

   ' Expects:
   '   &theModel  = points to the destination model
   '   file       = file handle to read from
   dim &theFrame as SMD2_frame
   ' Allocate frames
   alloc theModel.frames, theModel.header.num_frames - 1
   
   ' Seek to frames
   Seek (theFile, theModel.header.ofs_frames)
   dim i2, tempStr$,i3
   ' Load frames
   for i = 0 to theModel.header.num_frames - 1
       &theFrame = &theModel.frames (i)
       
       for i2 = 0 to 2
           theFrame.scale# (i2) = ReadFloat (theFile)
       next
       for i2 = 0 to 2
           theFrame.translate# (i2) = ReadFloat (theFile)
       next
       tempStr$ = ""
       for i2 = 1 to 16: tempStr$ = tempStr$ + ReadChar (theFile): next   ' Read name            
       while Len (tempStr$) > 0 and Right$ (tempStr$, 1) <= " "        ' Trim whitespace from right
           tempStr$ = Left$ (tempStr$, Len (tempStr$) - 1)
       wend
       theFrame.name$ = tempStr$
       
       ' Allocate vertices
       alloc theFrame.verts, theModel.header.num_xyz
       
       ' Read vertices
       for i2 = 0 to theModel.header.num_xyz - 1
           for i3 = 0 to 2
               theFrame.verts (i2).v# (i3) = ReadByte (theFile)
           next
           theFrame.verts (i2).normal = ReadByte (theFile)
       next    
   next
   
   return 0

endfunction
   
''''''''''''''''''
' Main functions

' LoadMD2
' Input:  theFileName$ = file to load
' Output: theModel     = MD2 model

function LoadMD2(&theModel as MD2_Model,FilePath as string,FileName as string)

   ' Open file
   TheModel.theFile = OpenFileRead (FilePath+FileName)
   
   if FileError() <> "" then
       printr fileError()
       end
       return 0
           
   endif
   
   theModel.FileFolder = FilePath
   theModel.interp = false
   theModel.First = true
   ' Allocate model
   'alloc theModel

   ' Read header
   LoadMD2Header(theModel.header, TheModel.theFile)
   
   ' Read data
   LoadMD2Skins(theModel, TheModel.theFile)                      ' Skins
   LoadMD2ST(theModel, TheModel.theFile)                         ' Texture coordinates (s, t)    
   LoadMD2Tris(theModel, TheModel.theFile)                       ' Triangles
   
   LoadMD2Frames(theModel, TheModel.theFile)                     ' Frames

   ' Close file and return
   CloseFile (TheModel.theFile)
   
   return 0

endfunction

function SetNextFrame(&Model as MD2_Model,frame)

   Model.frameNum2 = frame
   
   return 0

endfunction

function SetFrame(&Model as MD2_Model,frame)

   Model.frameNum = frame
   
   return 0

endfunction

function UpdateMD2(&theModel as MD2_Model,FirstFrame,LastFrame,Speed as single,Pos() as single, Rot() as single,Scale() as single)

   return 0
   
endfunction

function DrawMD2(&theModel as MD2_Model,FirstFrame,LastFrame,Speed as single,pos() as single,rot() as single,scale() as single)

   dim Direction = LastFrame - FirstFrame,change = false,SMD2_triangle &theTriangle, i2
   
   if theModel.first then
       theModel.prefirst = FirstFrame
       theModel.prelast  = LastFrame
       theModel.first = false
   else
       if theModel.prefirst <> FirstFrame then
           theModel.preFirst = FirstFrame
           change = true
           themodel.interp = true
           themodel.hold = theModel.framenum
       endif
       if theModel.prelast <> LastFrame then
           theModel.prelast = LastFrame
           change = true
           themodel.interp = true
           themodel.hold = theModel.framenum
       endif
   endif                            

   if theModel.frameNum < FirstFrame and Direction > 0 and not themodel.interp then
       SetFrame(theModel,FirstFrame)
       if LastFrame - FirstFrame > 0 then
           SetNextFrame(theModel,FirstFrame + 1)
       else
           SetNextFrame(theModel,FirstFrame)
           theModel.still = true
       endif
   endif    

   if not theModel.still then
       theModel.CurrentFrame = theModel.CurrentFrame + Speed
       if theModel.CurrentFrame >= 1 then
           theModel.CurrentFrame = theModel.CurrentFrame - 1
           themodel.interp = false
           theModel.FrameNum = theModel.FrameNum2
           theModel.still = true
       endif
   endif
   
   if Direction > 0 then
       if theModel.FrameNum2 < LastFrame+1 then
           if theModel.FrameNum2 = FirstFrame and theModel.FrameNum = LastFrame then
           else
               SetNextFrame(theModel,theModel.FrameNum + 1)
           endif
       elseif theModel.FrameNum2 > LastFrame then    
           SetNextFrame(theModel,FirstFrame)
       endif
   else
   endif
   
   if themodel.interp then
       SetFrame(theModel,themodel.hold)
       SetNextFrame(theModel,FirstFrame)
   endif
   
   if theModel.frameNum2 > theModel.header.num_frames-1 then
       SetNextFrame(theModel,theModel.header.num_frames-1)
   endif

   dim tempVec# (2)

   dim theHeader as SMD2_header = theModel.header
   theModel.theFrame  = theModel.frames (theModel.FrameNum)
   theModel.theFrame2 = theModel.frames (theModel.FrameNum2)

   ' Bind texture    
   glEnable (GL_CULL_FACE)
   glCullFace (GL_FRONT)
   glEnable (GL_TEXTURE_2D)
   glBindTexture (GL_TEXTURE_2D, theModel.skins (0))
   
   ' Setup texture scaling
   glMatrixMode (GL_TEXTURE)
   glPushMatrix ()
   glScalef (1.0 / theHeader.skinWidth, -1.0 / theHeader.skinHeight, 1)
   glMatrixMode (GL_MODELVIEW)
   
   ' Apply model scaling
   glPushMatrix ()
   glrotatef(-rot(2)-90,1,0,0)
   glrotatef(-rot(0),0,1,0)
   glrotatef(-rot(1)-90,0,0,1)
   'tempVec# = theModel.theFrame.translate# * (1 - theModel.CurrentFrame) + theModel.theFrame2.translate# * theModel.CurrentFrame
   'glTranslatef (tempVec# (0), tempVec# (1), tempVec# (2))
   tempVec# = theModel.theFrame.scale# * (1 - theModel.CurrentFrame) + theModel.theFrame2.scale# * theModel.CurrentFrame
   glScalef     (tempVec# (0), tempVec# (1), tempVec# (2))
   
   if theModel.frameNum = theModel.frameNum2 then
       theModel.still = true
   else
       theModel.still = false
   endif

   glpushmatrix()
                    '1               '0
       gltranslatef(pos(1),pos(2),pos(0))
       glScalef(scale(0),scale(1),scale(2))

       glBegin (GL_TRIANGLES)    
           for i = 0 to theHeader.num_tris - 1
               &theTriangle = &theModel.tris (i)
               for i2 = 0 to 2
                   'glNormal3fv (theModel.theFrame.verts (theTriangle.index_xyz (i2)).normal)
                   glTexCoord2fv (theModel.st# (theTriangle.index_st (i2)))
                   if not theModel.still then
                       glVertex3fv (theModel.theFrame.verts (theTriangle.index_xyz (i2)).v# * (1 - theModel.CurrentFrame) + theModel.theFrame2.verts (theTriangle.index_xyz (i2)).v# * theModel.CurrentFrame)
                   else
                       glVertex3fv (theModel.theFrame.verts (theTriangle.index_xyz (i2)).v#)
                   endif
               next
           next
       glEnd ()
   glpopmatrix()
   
   ' Restore modelview matrix
   glPopMatrix ()
   
   ' Restore texture matrix
   glMatrixMode (GL_TEXTURE)
   glPopMatrix ()
   glMatrixMode (GL_MODELVIEW)
   glCullFace (GL_BACK)
   
   return 0

endfunction

(hope thats everything )

So basically, that works out just fine. BUT ITS SLOW!!! And 99% of the lag comes from none other than the interpolation. That one line of glVertexfv() brings frame rates down from about a max of 400 to around 80.... HORREY SHEIT! Theres gotta be a better method. I was thinking that the interpolated verticies could be updated maybe once every 3 frames. MAY cause jumpy animation, but i can risk that. Unfortunately, i dont have the patience to work with this code anymore. It works, but isnt very useful when it brings down framerate to absolutely nothing.

I guess what im asking is: Is there either a better way to do animation(that wont take forever to write an importer) or should this just be optimized to be able to run at decent framerates?

[matthew]

Personally speaking I'd just try & optimize what you've already got.

I never really fully understood the MD2 format but I know there is a huge amount of information on the Internet about it. Have you tried visiting this site to get some ideas.

[shadow008]

Alright. I spoze i could just tinker with it. One thing I just thought about is that vertices that are culled out don't have to be interpolated... That's about half the verts every frame. Also, the interpolation could be done in the vertex shader. Those 300 MHz really come in handy when your processor is overloaded on the interpreted language.

Never the less, i STILL don't have the patience to work with this. I guess I'll just wait on it for a while.

[DJLinux]

If you load a model than you have to look self witch triangles build a part of the object.

For each part you have to create a precompiled OpenGL list
now if a frame number changed
you have to scale,rotate and move only the precompiled GL list

but if you interpolate and render every tringle seperate
it's normal to get low FPS rates.

Joshy

[shadow008]

If you load a model than you have to look self witch triangles build a part of the object.

Elaborate?

For each part you have to create a precompiled OpenGL list
now if a frame number changed
you have to scale,rotate and move only the precompiled GL list

What i think your trying to say is that i should precompile the individual frames... But that defeats the purpose of interpolation. And the frames rendered without interpolation look REALLY BAD! I could always use glDrawElements() (with the opengl 1.1 plugin), but I really dont understand why your trying to make your own pointer class. Seems slow to change individual variables with SetByte(), however i noticed a command called Copy.... if that does what i think it does, I would have had no problem with rendering lag. But most of the interpolation is slow. Calculating a bunch of interframes would work at the cost of memory. But precalculating a bunch of interframes would work for ALL characters using the same model... : \

[DJLinux]

shadow
i know nothing about MD2 animated objects
but i think the design of it schould be of
individual parts connected via joints is it right ?

Or the model animation could be made via connected bones.

How ever
you must find out witch triangles build an individual part.
you can try it via math or the parts have individual names ?

I don't mean to make an OpenGL list for every animated frame
i mean one OpenGL list for a part of an model.
(feet, leg, body, arm, hand, head, and so on)

If you like upload a complete working code of your MD2 loader
and one md2 model and it's textures as *.zip file.

(Again sorry about my bad english )

Joshy

[shadow008]

DJLinux:

Md2 is OLD SCHOOL. It goes with keyframed vertices... No bones, no parts controlled by joints... just vertices. The newer md5 goes with bones with weighted vertices for each bone, but I have no real reason to write an md5 parser/ renderer.

So actually no. Since there are no "parts", I don't think that an OpenGL list for the individual "parts" is possible XD

And actually, there's an md2 viewer that came with Basic4GL. I just quickly converted that to use subs/functions instead of GOSUB and GOTO.

I actually started writing my own modeler to use .obj models and have joints to control each one. But that was a while ago and i ran into some problems. Mainly with the mouse to 3d being in local space. And at the time i had no idea how to convert it. Heres that if you want to look at it : /

Attachments:

[Darkjester]

One thing I just thought about is that vertices that are culled out don't have to be interpolated... That's about half the verts every frame.

So actually no. Since there are no "parts", I don't think that an OpenGL list for the individual "parts" is possible XD

yes you could just cull and interpolate. Having not read your code im assuming you will update the texturecoordinates of uninterpolated vertices to keep your texture from messing up?


Edit:
Great job so far, im impressed, you have come along way since we got together on IM and worked on stuff

[shadow008]

yes you could just cull and interpolate. Having not read your code im assuming you will update the texturecoordinates of uninterpolated vertices to keep your texture from messing up?

No, its hardly noticeable. I was thinking of doing interpolation completely separate from rendering by using glDrawElements(), but i still dont understand how DJLinux's plugin requires its own separate pointer class... It seems far to slow to be useful (Unless theres another reason?)

Edit:
Great job so far, im impressed, you have come along way since we got together on IM and worked on stuff

Why thank you! Back in the good ol' days before Triston moved...

[lal7777]

Hey shadow008, did you ever figure out how to work blenders exported md2 models?
(or are those the ones your already talking about?)