doxygen/html/md2_8cpp_source.html

 #include "md2.h"

 #include "../../shared/ufotypes.h"

 #include "../../common/mem.h"

 #include "../../shared/shared.h"

 #include "../../common/filesys.h"

 #include "../../shared/typedefs.h"

 #include "../../common/mem.h"

 #include "../../common/common.h"

 #include "../../shared/byte.h"


 void MD2HeaderCheck (const dMD2Model_t* md2, const char* fileName, int bufSize)

 {

     /* sanity checks */

     const uint32_t version = LittleLong(md2->version);

     const uint32_t numSkins = LittleLong(md2->num_skins);

     const uint32_t numTris = LittleLong(md2->num_tris);

     const uint32_t numVerts = LittleLong(md2->num_verts);

     const uint32_t ident = LittleLong(md2->ident);


     if (ident != IDALIASHEADER)

         Com_Error(ERR_DROP, "%s is no valid md2 file", fileName);


     if (version != MD2_ALIAS_VERSION)

         Com_Error(ERR_DROP, "%s has wrong version number (%i should be %i)", fileName, version, MD2_ALIAS_VERSION);


     if (bufSize != LittleLong(md2->ofs_end))

         Com_Error(ERR_DROP, "model %s broken offset values (%i, %i)", fileName, bufSize, LittleLong(md2->ofs_end));


     if (numSkins == 0 || numSkins >= MD2_MAX_SKINS)

         Com_Error(ERR_DROP, "model '%s' has invalid skin number: %i", fileName, numSkins);


     if (numVerts == 0 || numVerts >= MD2_MAX_VERTS)

         Com_Error(ERR_DROP, "model %s has too many (or no) vertices (%i/%i)", fileName, numVerts, MD2_MAX_VERTS);


     if (numTris == 0 || numTris >= MD2_MAX_TRIANGLES)

         Com_Error(ERR_DROP, "model %s has too many (or no) triangles (%i/%i)", fileName, numTris, MD2_MAX_TRIANGLES);

 }


 void MD2SkinEdit (const byte* buf, const char* fileName, int bufSize, void* userData)

 {

     uint32_t numSkins;

     byte* const copy = Mem_Dup(byte, buf, bufSize);

     dMD2Model_t* md2 = (dMD2Model_t*)copy;

     char* md2Path;


     MD2HeaderCheck(md2, fileName, bufSize);


     md2Path = (char*) copy + LittleLong(md2->ofs_skins);

     numSkins = LittleLong(md2->num_skins);


     Com_Printf("  \\ - skins %i\n", numSkins);

     for (int i = 0; i < numSkins; i++) {

         char* name = md2Path + i * MD2_MAX_SKINNAME;

         Com_Printf("  \\ - skin %i: %s\n", i + 1, name);

         printf("  \\ - new skin: ");

         fflush(stdout);

         scanf(va("%%%is", MD2_MAX_SKINNAME), name);

     }


     ScopedFile md2ModelFile;

     FS_OpenFile(fileName, &md2ModelFile, FILE_WRITE);

     if (!md2ModelFile) {

         Com_Printf("Error writing md2 file %s\n", fileName);

         Mem_Free(copy);

         return;

     }

     FS_Write(copy, bufSize, &md2ModelFile);

     Mem_Free(copy);

 }


 void MD2Info (const byte* buf, const char* fileName, int bufSize, void* userData)

 {

     const dMD2Model_t* md2 = (const dMD2Model_t*)buf;


     MD2HeaderCheck(md2, fileName, bufSize);


     const uint32_t numSkins = LittleLong(md2->num_skins);

     const uint32_t numVerts = LittleLong(md2->num_verts);

     const uint32_t numST = LittleLong(md2->num_st);

     const uint32_t numTris = LittleLong(md2->num_tris);

     const uint32_t numGLCmds = LittleLong(md2->num_glcmds);

     const uint32_t numFrames = LittleLong(md2->num_frames);

     const uint32_t frameSize = LittleLong(md2->framesize);

     const uint32_t skinHeight = LittleLong(md2->skinheight);

     const uint32_t skinWidth = LittleLong(md2->skinwidth);

     const uint32_t version = LittleLong(md2->version);


     const uint32_t ofsST = LittleLong(md2->ofs_st);

     const uint32_t ofsTris = LittleLong(md2->ofs_tris);

     const uint32_t ofsFrames = LittleLong(md2->ofs_frames);

     const uint32_t ofsGLCmds = LittleLong(md2->ofs_glcmds);

     const uint32_t ofsEnd = LittleLong(md2->ofs_end);

     const uint32_t ofsSkins = LittleLong(md2->ofs_skins);


     const char* md2Path = (const char*) md2 + LittleLong(md2->ofs_skins);


     Com_Printf("  \\ - skins %i\n", numSkins);

     for (int i = 0; i < numSkins; i++) {

         const char* name = md2Path + i * MD2_MAX_SKINNAME;

         Com_Printf("    \\ -> skin %i: %s\n", i + 1, name);

     }

     Com_Printf("  \\ - vertices %i\n", numVerts);

     Com_Printf("  \\ - texcoords %i\n", numST);

     Com_Printf("  \\ - tris %i\n", numTris);

     Com_Printf("  \\ - glcmds %i\n", numGLCmds);

     Com_Printf("  \\ - frames %i\n", numFrames);

     Com_Printf("  \\ - frameSize %i\n", frameSize);

     Com_Printf("  \\ - skinHeight %i\n", skinHeight);

     Com_Printf("  \\ - skinWidth %i\n", skinWidth);

     Com_Printf("  \\ - version %i\n", version);

     Com_Printf("  \\ - offsets\n");

     Com_Printf("    \\ - ofsST %i\n", ofsST);

     Com_Printf("    \\ - ofsTris %i\n", ofsTris);

     Com_Printf("    \\ - ofsFrames %i\n", ofsFrames);

     Com_Printf("    \\ - ofsGLCmds %i\n", ofsGLCmds);

     Com_Printf("    \\ - ofsSkins %i\n", ofsSkins);

     Com_Printf("    \\ - ofsEnd %i\n", ofsEnd);

 }


 void MD2SkinNum (const byte* buf, const char* fileName, int bufSize, void* userData)

 {

     byte* copy = Mem_Dup(byte, buf, bufSize);

     dMD2Model_t* md2 = (dMD2Model_t*)copy;


     MD2HeaderCheck(md2, fileName, bufSize);


     const uint32_t numSkins = LittleLong(md2->num_skins);


     const uint32_t ofsST = LittleLong(md2->ofs_st);

     const uint32_t ofsTris = LittleLong(md2->ofs_tris);

     const uint32_t ofsFrames = LittleLong(md2->ofs_frames);

     const uint32_t ofsGLCmds = LittleLong(md2->ofs_glcmds);

     const uint32_t ofsEnd = LittleLong(md2->ofs_end);

     const uint32_t ofsSkins = LittleLong(md2->ofs_skins);


     uint32_t moveOffset = ofsEnd;

 #define CHECKMAX(val)   if ((val) > ofsSkins && (val) < moveOffset) moveOffset = (val);

     CHECKMAX(ofsST);

     CHECKMAX(ofsTris);

     CHECKMAX(ofsFrames);

     CHECKMAX(ofsGLCmds);

     CHECKMAX(ofsSkins);

 #undef CHECKMAX


     Com_Printf("  \\ - skins %i\n", numSkins);

     int newSkins = 0;

     printf("  \\ - new skin number: ");

     fflush(stdout);

     scanf("%i", &newSkins);

     if (newSkins <= 0) {

         Com_Printf("A model must have a skin\n");

         Mem_Free(copy);

         return;

     }

     if (newSkins > MD2_MAX_SKINS) {

         Com_Printf("Only %i skins are allowed\n", MD2_MAX_SKINS);

         Mem_Free(copy);

         return;

     }


     if (newSkins == numSkins) {

         Mem_Free(copy);

         return;

     }


     const int32_t deltaSkins = newSkins - numSkins;

     const int32_t offsetDelta = deltaSkins * MD2_MAX_SKINNAME;

     if (ofsST > ofsSkins)

         md2->ofs_st = LittleLong(ofsST + offsetDelta);

     if (ofsTris > ofsSkins)

         md2->ofs_tris = LittleLong(ofsTris + offsetDelta);

     if (ofsFrames > ofsSkins)

         md2->ofs_frames = LittleLong(ofsFrames + offsetDelta);

     if (ofsGLCmds > ofsSkins)

         md2->ofs_glcmds = LittleLong(ofsGLCmds + offsetDelta);

     md2->ofs_end = LittleLong(ofsEnd + offsetDelta);

     md2->num_skins = LittleLong(newSkins);


     Com_Printf("change to %i skins\n", newSkins);

     if (deltaSkins > 0) {

         copy = (byte*)Mem_ReAlloc(copy, md2->ofs_end);

         md2 = (dMD2Model_t*)copy;

     }


     const int n = ofsEnd - moveOffset;

     byte* from = copy + moveOffset;

     byte* to = from + offsetDelta;

     memmove(to, from, n);


     if (deltaSkins > 0) {

         char*  md2Path = (char*) copy + LittleLong(md2->ofs_skins);

         for (int i = numSkins; i < numSkins + deltaSkins; i++) {

             char* name = md2Path + i * MD2_MAX_SKINNAME;

             memset(name, 0, MD2_MAX_SKINNAME);

             strcpy(name, ".none");

             Com_Printf("  \\ - skin %i: %s\n", i + 1, name);

             printf("  \\ - new skin: ");

             fflush(stdout);

             scanf(va("%%%is", MD2_MAX_SKINNAME), name);

         }

     }

     ScopedFile md2ModelFile;

     FS_OpenFile(fileName, &md2ModelFile, FILE_WRITE);

     if (!md2ModelFile) {

         Com_Printf("Error writing md2 file %s\n", fileName);

         Mem_Free(copy);

         return;

     }

     FS_Write(copy, md2->ofs_end, &md2ModelFile);

     Mem_Free(copy);

 }


 void MD2GLCmdsRemove (const byte* buf, const char* fileName, int bufSize, void* userData)

 {

     uint32_t numGLCmds;

     const dMD2Model_t* md2 = (const dMD2Model_t*)buf;


     MD2HeaderCheck(md2, fileName, bufSize);


     numGLCmds = LittleLong(md2->num_glcmds);


     if (numGLCmds > 0) {

         byte        *const copy     = Mem_Dup(byte, buf, bufSize);

         dMD2Model_t* const fixedMD2 = (dMD2Model_t*)copy;

         const size_t delta = numGLCmds * sizeof(uint32_t);

         const uint32_t offset = LittleLong(fixedMD2->ofs_glcmds);


         if (LittleLong(fixedMD2->ofs_skins) > offset || LittleLong(fixedMD2->ofs_frames) > offset

          || LittleLong(fixedMD2->ofs_st) > offset || LittleLong(fixedMD2->ofs_tris) > offset) {

             Com_Error(ERR_DROP, "Unexpected order of the different data lumps");

         }


         fixedMD2->ofs_end = LittleLong(fixedMD2->ofs_end - delta);

         fixedMD2->ofs_glcmds = 0;

         fixedMD2->num_glcmds = 0;


         bufSize -= delta;


         FS_WriteFile(fixedMD2, bufSize, fileName);


         Mem_Free(copy);


         *(size_t*)userData += delta;

         Com_Printf("  \\ - removed %i glcmds from '%s' (save " UFO_SIZE_T " bytes)\n",

                 numGLCmds, fileName, delta);

     }

 }

dMD2Model_t::skinheight
uint32_t skinheight
Definition: qfiles.h:118

IDALIASHEADER
#define IDALIASHEADER
Definition: qfiles.h:40

dMD2Model_t::num_skins
uint32_t num_skins
Definition: qfiles.h:121

Mem_ReAlloc
#define Mem_ReAlloc(ptr, size)
Definition: mem.h:44

MD2_MAX_SKINS
#define MD2_MAX_SKINS
Definition: qfiles.h:48

MD2SkinEdit
void MD2SkinEdit(const byte *buf, const char *fileName, int bufSize, void *userData)
Definition: md2.cpp:39

dMD2Model_t::num_tris
uint32_t num_tris
Definition: qfiles.h:124

FS_OpenFile
int FS_OpenFile(const char *filename, qFILE *file, filemode_t mode)
Finds and opens the file in the search path.
Definition: files.cpp:162

MD2_ALIAS_VERSION
#define MD2_ALIAS_VERSION
Definition: qfiles.h:42

va
const char * va(const char *format,...)
does a varargs printf into a temp buffer, so I don't need to have varargs versions of all text functi...
Definition: shared.cpp:410

dMD2Model_t::num_st
uint32_t num_st
Definition: qfiles.h:123

MD2_MAX_SKINNAME
#define MD2_MAX_SKINNAME
Definition: qfiles.h:49

Com_Printf
void Com_Printf(const char *const fmt,...)
Definition: common.cpp:386

MD2SkinNum
void MD2SkinNum(const byte *buf, const char *fileName, int bufSize, void *userData)
Definition: md2.cpp:120

dMD2Model_t::ofs_end
uint32_t ofs_end
Definition: qfiles.h:133

buf
voidpf void * buf
Definition: ioapi.h:42

dMD2Model_t::num_glcmds
uint32_t num_glcmds
Definition: qfiles.h:125

MD2Info
void MD2Info(const byte *buf, const char *fileName, int bufSize, void *userData)
Definition: md2.cpp:71

Com_Error
void Com_Error(int code, const char *fmt,...)
Definition: common.cpp:417

dMD2Model_t::framesize
uint32_t framesize
Definition: qfiles.h:119

ERR_DROP
#define ERR_DROP
Definition: common.h:211

dMD2Model_t::ofs_glcmds
uint32_t ofs_glcmds
Definition: qfiles.h:132

dMD2Model_t::ofs_skins
uint32_t ofs_skins
Definition: qfiles.h:128

MD2_MAX_VERTS
#define MD2_MAX_VERTS
Definition: qfiles.h:46

FS_WriteFile
int FS_WriteFile(const void *buffer, size_t len, const char *filename)
Definition: files.cpp:1544

MD2GLCmdsRemove
void MD2GLCmdsRemove(const byte *buf, const char *fileName, int bufSize, void *userData)
Definition: md2.cpp:213

dMD2Model_t::num_frames
uint32_t num_frames
Definition: qfiles.h:126

dMD2Model_t::ofs_frames
uint32_t ofs_frames
Definition: qfiles.h:131

dMD2Model_t::ofs_tris
uint32_t ofs_tris
Definition: qfiles.h:130

dMD2Model_t
the glcmd format: a positive integer starts a tristrip command, followed by that many vertex structur...
Definition: qfiles.h:109

dMD2Model_t::ofs_st
uint32_t ofs_st
Definition: qfiles.h:129

i
QGL_EXTERN GLint i
Definition: r_gl.h:113

MD2HeaderCheck
void MD2HeaderCheck(const dMD2Model_t *md2, const char *fileName, int bufSize)
Definition: md2.cpp:11

name
QGL_EXTERN GLuint GLsizei GLsizei GLint GLenum GLchar * name
Definition: r_gl.h:110

MD2_MAX_TRIANGLES
#define MD2_MAX_TRIANGLES
Definition: qfiles.h:45

Mem_Free
#define Mem_Free(ptr)
Definition: mem.h:35

UFO_SIZE_T
#define UFO_SIZE_T
Definition: ufotypes.h:89

dMD2Model_t::version
uint32_t version
Definition: qfiles.h:115

FILE_WRITE
Definition: filesys.h:111

offset
voidpf uLong offset
Definition: ioapi.h:45

dMD2Model_t::num_verts
uint32_t num_verts
Definition: qfiles.h:122

byte
uint8_t byte
Definition: ufotypes.h:34

bufSize
QGL_EXTERN GLuint GLsizei bufSize
Definition: r_gl.h:110

Mem_Dup
#define Mem_Dup(type, in, n)
Definition: mem.h:47

dMD2Model_t::skinwidth
uint32_t skinwidth
Definition: qfiles.h:117

CHECKMAX
#define CHECKMAX(val)

ScopedFile
Definition: filesys.h:186

md2.h

dMD2Model_t::ident
uint32_t ident
Definition: qfiles.h:110

LittleLong
#define LittleLong(X)
Definition: byte.h:37

FS_Write
int FS_Write(const void *buffer, int len, qFILE *f)
Properly handles partial writes.
Definition: files.cpp:1511