MS_Bone.cpp

Go to the documentation of this file.

#include "MilkShape.h"

MS_Bone::MS_Bone() {
        this->keyFramesTrans    = NULL;
        this->keyFramesRot              = NULL;
        this->parent                    = NULL;
}

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

void MS_Bone::clear() {
        if (this->keyFramesTrans) {
                free(keyFramesTrans);
                keyFramesTrans = NULL;
        }

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

void MS_Bone::render() {
        MS_Vec vector;
        MS_Vec parentvector;

        vector.x = 0.0f;
        vector.y = 0.0f;
        vector.z = 0.0f;
        vector.w = 1.0f;

        MS_Vec_Transform(&vector, &this->matFinal);

        if (this->parent) {
                parentvector.x = 0.0f;
                parentvector.y = 0.0f;
                parentvector.z = 0.0f;
                parentvector.w = 1.0f;
                MS_Vec_Transform(&parentvector, &this->parent->matFinal);
        }

        glDisable(GL_TEXTURE_2D);

        // render bones as lines
        glLineWidth(1.0f);
        glColor3f(1.0f, 0.0f, 0.0f);
        glBegin(GL_LINES);
                glVertex3f(vector.x, vector.y, vector.z);
                if (this->parent)
                        glVertex3f(parentvector.x, parentvector.y, parentvector.z);
                else
                        glVertex3f(vector.x, vector.y, vector.z);
        glEnd();

        // render bone-ends
        glPointSize(4.0f);
        glColor3f(1.0f, 0.0f, 1.0f);
        glBegin(GL_POINTS);
                glVertex3f(vector.x, vector.y, vector.z);
                if (this->parent)
                        glVertex3f(parentvector.x, parentvector.y, parentvector.z);
        glEnd();

        glColor3f(1.0f, 1.0f, 1.0f);
}

bool MS_Bone::loadFromAsciiSegment(FILE *file) {
        char szLine[256] = {0};
        int j, nFlags;

        if (!fgets(szLine, 256, file)) {
                return false;
        }

        //--------------------
        // Name
        //--------------------
        if (sscanf(szLine, "\"%[^\"]\"", this->name) != 1) {
                return false;
        }

        //--------------------
        // Parent name
        //--------------------
        if (!fgets(szLine, 256, file))
                return false;
        strcpy(this->parentName, "");
        sscanf(szLine, "\"%[^\"]\"", this->parentName);

        //--------------------
        // Position and rotation
        //--------------------
        if (!fgets(szLine, 256, file))
                return false;
        if (sscanf(szLine, "%d %f %f %f %f %f %f",
                                                &nFlags,
                                                &this->position[0], &this->position[1], &this->position[2],
                                                &this->rotation[0], &this->rotation[1], &this->rotation[2]) != 7) {
                return false;
        }

        //--------------------
        // Position key count
        //--------------------
        if (!fgets(szLine, 256, file))
                return false;
        if (sscanf(szLine, "%d", &this->numPosKeys) != 1)
                return false;

        this->keyFramesTrans = (MS_KeyFramePos *)malloc(sizeof(MS_KeyFramePos) * this->numPosKeys);
        for (j=0; j<this->numPosKeys; j++) {
                if (!fgets(szLine, 256, file))
                        return false;
                if (sscanf(szLine, "%f %f %f %f", &this->keyFramesTrans[j].time,
                                                                                  &this->keyFramesTrans[j].position[0],
                                                                                  &this->keyFramesTrans[j].position[1],
                                                                                  &this->keyFramesTrans[j].position[2]) != 4) {
                        return false;
                }
        }

        //--------------------
        // Rotation key count
        //--------------------
        if (!fgets(szLine, 256, file))
                return false;
        if (sscanf(szLine, "%d", &this->numRotKeys) != 1)
                return false;

        this->keyFramesRot = (MS_KeyFrameRot *)malloc(sizeof(MS_KeyFrameRot) * this->numRotKeys);
        for (j=0; j<this->numRotKeys; j++) {
                if (!fgets(szLine, 256, file))
                        return false;
                if (sscanf(szLine, "%f %f %f %f", &this->keyFramesRot[j].time,
                                                                                  &this->keyFramesRot[j].position[0],
                                                                                  &this->keyFramesRot[j].position[1],
                                                                                  &this->keyFramesRot[j].position[2]) != 4) {
                        return false;
                }
        }

        return true;
}

void MS_Bone::initialize() {
        Mat4 m_rel;

        m_rel.loadRotateZXY(this->rotation[0], this->rotation[1], this->rotation[2]);
        m_rel.setTranslate(Vec3(this->position[0], this->position[1], this->position[2]));

        if (this->parent == NULL) {
                this->matFinal = m_rel;
        }
        else {
                this->matFinal = this->parent->matFinal;
                this->matFinal *= m_rel;
        }
}

void MS_Bone::advanceTo(float fCurrentTime) {
        int i;
        float deltaTime;
        float fraction;
        float Position[3];
        float Rotation[3];

        //--------------------
        // Position
        //--------------------
        i = 0;
        while (i<this->numPosKeys-1 && this->keyFramesTrans[i].time < fCurrentTime)
                i++;

        assert(i < this->numPosKeys);

        // Interpolate between two key frames
        if (i > 0) {
                deltaTime = this->keyFramesTrans[i].time - this->keyFramesTrans[i-1].time;

                assert(deltaTime > 0.0f);

                fraction = (fCurrentTime - this->keyFramesTrans[i-1].time) / deltaTime;

                assert(fraction > 0.0f);
                assert(fraction < 1.0f);

                Position[0] = this->keyFramesTrans[i-1].position[0] + fraction * (this->keyFramesTrans[i].position[0] - this->keyFramesTrans[i-1].position[0]);
                Position[1] = this->keyFramesTrans[i-1].position[1] + fraction * (this->keyFramesTrans[i].position[1] - this->keyFramesTrans[i-1].position[1]);
                Position[2] = this->keyFramesTrans[i-1].position[2] + fraction * (this->keyFramesTrans[i].position[2] - this->keyFramesTrans[i-1].position[2]);
        }
        else {
                memcpy(Position, this->keyFramesTrans[i].position, 3*sizeof(float));
        }

        //--------------------
        // Rotation
        //--------------------
        i = 0;
        while (i<this->numRotKeys-1 && this->keyFramesRot[i].time < fCurrentTime)
                i++;

        assert(i < this->numRotKeys);

        // Interpolate between two key frames
        if (i > 0) {
                deltaTime = this->keyFramesRot[i].time - this->keyFramesRot[i-1].time;

                assert(deltaTime > 0.0f);

                fraction = (fCurrentTime - this->keyFramesRot[i-1].time) / deltaTime;

                assert(fraction > 0.0f);
                assert(fraction < 1.0f);

                Rotation[0] = this->keyFramesRot[i-1].position[0] + fraction * (this->keyFramesRot[i].position[0] - this->keyFramesRot[i-1].position[0]);
                Rotation[1] = this->keyFramesRot[i-1].position[1] + fraction * (this->keyFramesRot[i].position[1] - this->keyFramesRot[i-1].position[1]);
                Rotation[2] = this->keyFramesRot[i-1].position[2] + fraction * (this->keyFramesRot[i].position[2] - this->keyFramesRot[i-1].position[2]);
        }
        else {
                memcpy(Rotation, this->keyFramesRot[i].position, 3*sizeof(float));
        }

        //--------------------
        // Transformation matrix
        //--------------------
        Mat4 m_rel;
        Mat4 m_frame;

        m_rel.loadRotateZXY(this->rotation[0], this->rotation[1], this->rotation[2]);
        m_rel.setTranslate(Vec3(this->position[0], this->position[1], this->position[2]));

        m_frame.loadRotateZXY(Rotation[0], Rotation[1], Rotation[2]);
        m_frame.setTranslate(Vec3(Position[0], Position[1], Position[2]));

        m_rel *= m_frame;

        if (this->parent == NULL) {
                this->matFinal = m_rel;
        }
        else {
                this->matFinal = this->parent->matFinal;
                this->matFinal *= m_rel;
        }
}

---