MilkShape.cpp

Go to the documentation of this file.

#include "MilkShape.h"

void MS_Vec_Transform(MS_Vec *pV, const Mat4 *pM) {
        float vector[4];
        const float *matrix = pM->getMatrix();

        vector[0] = pV->x * matrix[0] + pV->y * matrix[4] + pV->z * matrix[8] + matrix[12];
        vector[1] = pV->x * matrix[1] + pV->y * matrix[5] + pV->z * matrix[9] + matrix[13];
        vector[2] = pV->x * matrix[2] + pV->y * matrix[6] + pV->z * matrix[10] + matrix[14];
        vector[3] = pV->x * matrix[3] + pV->y * matrix[7] + pV->z * matrix[11] + matrix[15];

        pV->x = vector[0];
        pV->y = vector[1];
        pV->z = vector[2];
        pV->w = vector[3];

}

void MS_Vec_Transform3(MS_Vec *pV, const Mat4 *pM) {
        float vector[3];
        const float *matrix = pM->getMatrix();

        vector[0] = pV->x * matrix[0] + pV->y * matrix[4] + pV->z * matrix[8];
        vector[1] = pV->x * matrix[1] + pV->y * matrix[5] + pV->z * matrix[9];
        vector[2] = pV->x * matrix[2] + pV->y * matrix[6] + pV->z * matrix[10];

        pV->x = vector[0];
        pV->y = vector[1];
        pV->z = vector[2];
}

//-------------------------------------------------------------

MilkShape::MilkShape() {
        this->numMeshes = 0;
        this->pMeshes   = NULL;
        this->numBones  = 0;
        this->pBones    = NULL;
        this->numMaterials = 0;
        this->pMaterials = NULL;
        this->materialIndices = NULL;
}

MilkShape::~MilkShape() {
        clear();
}

void MilkShape::clear() {
        unsigned int i;

        if (this->pMeshes != NULL) {
                for (i=0; i<this->numMeshes; i++) {
                        //delete this->pMeshes[i];
                        pMeshes[i].clear();
                }
                //pMeshes->clear();
                free(pMeshes);
                pMeshes = NULL;
        }

        if (this->pMaterials != NULL) {
                for (i=0; i<this->numMaterials; i++) {
                        pMaterials[i].clear();
                }
                //pMaterials->clear();
                free(pMaterials);
                pMaterials = NULL;
        }

        if (this->pBones != NULL) {
                for (i=0; i<this->numBones; i++) {
                        pBones[i].clear();
                }
                //pBones->clear();
                free(pBones);
                pBones = NULL;
        }

        if (this->materialIndices != NULL) {
                free(this->materialIndices);
                this->materialIndices = NULL;
        }
}

bool MilkShape::linkBones() {
        int i, j;

        for (i=0; i<this->numBones; i++) {
                this->pBones[i].parent = NULL;

                // have a parent
                if (strlen(this->pBones[i].parentName) > 0) {
                        // search parent
                        for (j=0; j<this->numBones; j++) {
                                // j is pparent of i
                                if (stricmp(this->pBones[j].name, this->pBones[i].parentName) == 0) {
                                        this->pBones[i].parent = &this->pBones[j];
                                        break;
                                }
                        }

                        // unable to find parent
                        if (this->pBones[i].parent == NULL)
                                return false;
                }
        }

        return true;
}

void MilkShape::initializeBones() {
        int i;

        for (i=0; i<this->numBones; i++) {
                this->pBones[i].initialize();
        }
}

void MilkShape::attachSkin() {
        int i, j;
        int bone;
        Mat4 *pMatrix;
        float v[3];

        for (i=0; i<this->numMeshes; i++) {
                for (j=0; j<this->pMeshes[i].numVertices; j++) {
                        bone = this->pMeshes[i].vertices[j].bone;

                        // vertex attached to a bone
                        if (bone != -1) {
                                //pMatrix = this->pBones[bone].matFinal;
                                pMatrix = &this->pBones[bone].matFinal;

                                v[0] = this->pMeshes[i].vertices[j].x;
                                v[1] = this->pMeshes[i].vertices[j].y;
                                v[2] = this->pMeshes[i].vertices[j].z;

                                pMatrix->inverseTranslateVect(v);
                                pMatrix->inverseRotateVect(v);

                                this->pMeshes[i].vertices[j].x = v[0];
                                this->pMeshes[i].vertices[j].y = v[1];
                                this->pMeshes[i].vertices[j].z = v[2];
                        }
                }
        }
}

void MilkShape::renderBones() {
        for (int i=0; i<this->numBones; i++) {
                this->pBones[i].render();
        }
}

void MilkShape::advanceAnimation(float deltaTime) {
        int i;

        this->fCurrentTime += deltaTime;

        // loop animation
        if (this->fCurrentTime > this->fMaxTime)
                this->fCurrentTime = 1.0f;

        for (i=0; i<this->numBones; i++) {
                this->pBones[i].advanceTo(this->fCurrentTime);
        }
}

bool MilkShape::loadFromAsciiFile(const char *path, const char *filename) {
        float   StartTime;
        bool    bError = false;
        char    szpath[256];
        char    szLine[256] = {0};
        int             nFlags, nIndex, i;

        sprintf(szpath, "%s%s", path, filename);

        FILE *file = fopen(szpath, "r");
        if (!file) {
                LOG_ERROR(("Unable to locate MilkShape ASCII file: %s", szpath));
                return false;
        }

        //LOG_MISC(("Loading MilkShape ASCII file: %s", szpath));

        this->fCurrentTime = 0.0f;
        int nFrame;

        while (fgets(szLine, 256, file) != NULL && !bError) {
                if (!strncmp(szLine, "//", 2))
                        continue;

                // Length of animation
                if (sscanf(szLine, "Frames: %d", &nFrame) == 1) {
                        this->fMaxTime = 1.0f*nFrame;

                        //LOG_MISC(("Animation length: %f", this->fMaxTime));

                        continue;
                }

                if (sscanf(szLine, "Frame: %d", &nFrame) == 1) {
                        StartTime = 1.0f*nFrame;
                        //LOG_MISC(("Animation start time: %f", StartTime));
                        continue;
                }

                //--------------------
                // Meshes
                //--------------------
                if (sscanf(szLine, "Meshes: %d", &this->numMeshes) == 1) {
                        //LOG_MISC(("MilkShape # Loading mesh (%d)", this->numMeshes));

                        char szName[MS_MAX_NAME];

                        this->pMeshes = (MS_Mesh *)malloc(sizeof(MS_Mesh)*this->numMeshes);
                        this->materialIndices = (int *)malloc(sizeof(int)*this->numMeshes);

                        for (i=0; i<this->numMeshes && !bError; i++) {
                                if (!fgets(szLine, 256, file)) {
                                        LOG_MISC(("MilkShape # Error loading Mesh"));
                                        bError = true;
                                        break;
                                }

                                // mesh: name, flags, material index
                                if (sscanf(szLine, "\"%[^\"]\" %d %d", szName, &nFlags, &nIndex) != 3) {
                                        LOG_MISC(("MilkShape # Error loading Mesh info"));
                                        bError = true;
                                        break;
                                }
                                this->materialIndices[i] = nIndex;

                                if (!this->pMeshes[i].loadFromAsciiSegment(file)) {
                                        LOG_ERROR(("MilkShape # Error loading Mesh ascii segment"));
                                        bError = true;
                                        break;
                                }
                        }

                        //LOG_MISC(("MilkShape # Meshes loaded"));

                        continue;
                }
                
                //--------------------
                // Materials
                //--------------------
                if (sscanf(szLine, "Materials: %d", &this->numMaterials) == 1 && this->numMaterials > 0) {
                        //LOG_MISC(("MilkShape # Loading materials (%d)", this->numMaterials));

                        int i; // needed? don't think so

                        this->pMaterials = (MS_Material *)malloc(sizeof(MS_Material) * this->numMaterials);

                        for (i=0; i<this->numMaterials && !bError; i++) {
                                if (!this->pMaterials[i].loadFromAsciiSegment(path, file)) {
                                        LOG_ERROR(("MilkShape # Error loading Material ascii segment"));
                                        bError = true;
                                        break;
                                }
                        }

                        //LOG_MISC(("MilkShape # Materials loaded"));

                        continue;
                }

                //--------------------
                // Bones
                //--------------------
                if (sscanf(szLine, "Bones: %d", &this->numBones) == 1 && this->numBones > 0) {
                        //LOG_MISC(("MilkShape # Loading bones (%d)", this->numBones));

                        int i = 0; // don't needed either I think

                        this->pBones = (MS_Bone *)malloc(sizeof(MS_Bone) * this->numBones);

                        for (i=0; i<this->numBones && !bError; i++) {
                                if (!this->pBones[i].loadFromAsciiSegment(file)) {
                                        LOG_ERROR(("MilkShape # Error loading Bones ascii segment"));
                                        bError = true;
                                        break;
                                }
                        }

                        //LOG_MISC(("MilkShape # Bones loaded"));

                        continue;
                }

                //--------------------
                // Guns :)
                //--------------------
                if (sscanf(szLine, "Guns: %d", &this->numGuns) == 1 && this->numGuns > 0) {
                        if (this->numGuns > MS_PLAYER_MAX_GUNS) this->numGuns = MS_PLAYER_MAX_GUNS;

                        //LOG_MISC(("MilkShape # Loading guns (%d)", this->numGuns));

                        i = 0;

                        for (i=0; i<this->numGuns; i++) {
                                if (!fgets(szLine, 256, file))
                                        return false;
                                if (sscanf(szLine, "%f %f %f", &this->guns[i].x, &this->guns[i].y, &this->guns[i].z) != 3) {
                                        LOG_ERROR(("MilkShape # Error loading gun position"));
                                        return false;
                                }

                                //LOG_MISC(("x:%f, y:%f, z:%f", this->guns[i].x,this->guns[i].y,this->guns[i].z));
                        }

                        //LOG_MISC(("MilkShape # Guns loaded"));
                }
        }

        fclose(file);

        if (!this->linkBones())
                return false;

        this->initializeBones();
        this->attachSkin();
        this->advanceAnimation(StartTime);

        LOG_SUCCESS(("MilkShape ASCII file < %s >loaded", szpath));

        return true;
}

void MilkShape::render() {
        int k, i, j;
        MS_Tri          *pTri   = NULL;
        MS_Vec          *pVec   = NULL;
        MS_Normal       *pN             = NULL;
        MS_Bone         *pBone  = NULL;
        float           v[3];
        Mat4            *pMatrix;

        for (k=0; k<this->numMeshes; k++) {

                if (this->numMaterials > 0) {
                        int materialIndex = this->materialIndices[k];
                        if (materialIndex >= 0) {
                                this->pMaterials->activate();
                        }
                        else {
                                //glDisable(GL_TEXTURE_2D);
                        }
                }


                glBegin(GL_TRIANGLES);
                // for each triangle
                for (i=0; i<this->pMeshes[k].numTriangles; i++) {
                        pTri = this->pMeshes[k].triangles + i;

                        // for each vertex
                        for (j=0; j<3; j++) {

                                // normal
                                pN = this->pMeshes[k].normals + pTri->n[j];
                                glNormal3f(pN->x, pN->y, pN->z);

                                // texture coordinate
                                pVec = this->pMeshes[k].vertices + pTri->v[j];
                                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, pVec->u, pVec->v);


                                if (pVec->bone == -1) {
                                        glVertex3f(pVec->x, pVec->y, pVec->z);
                                }
                                else {
                                        pBone = &this->pBones[pVec->bone];
                                        pMatrix = &pBone->matFinal;
                                        v[0] = pVec->x;
                                        v[1] = pVec->y;
                                        v[2] = pVec->z;

                                        pMatrix->rotateVect(v);
                                        pMatrix->translateVect(v);

                                        glVertex3fv(v);
                                }
                        }
                }
                glEnd();

        }
}

---