mdl_utils.cpp.svn-base

自己做的小游戏

            if (strstr(pseqdescs[i].label,seqname))
                return i;
        }
    }
    return -1;
}

/*
  增加的函数，Chaos中主要通过这个函数来设置模型的行为状态，状态有五种
  通过调用FuzzySearchSeq找到合适的动画序列
*/
int MDLModel::SetSeq(int state)
{
    int iSequence = 0;
    switch (state)
    {
    case IDLE:
        iSequence = FuzzySearchSeq("idle");
        if (iSequence != -1)
        {
            SetSequence(iSequence);
            return iSequence;
        }
        break;

    case WALK:
        iSequence = FuzzySearchSeq("walk");
        if (iSequence != -1)
        {
            SetSequence(iSequence);
            return iSequence;
        }
        break;

    case RUN:
        iSequence = FuzzySearchSeq("run");
        if (iSequence != -1)
        {
            SetSequence(iSequence);
            return iSequence;
        }
        break;

    case ATTACK:
        iSequence = FuzzySearchSeq("attack");
        if (iSequence == -1)
            iSequence = FuzzySearchSeq("180L");
        if (iSequence != -1)
        {
            SetSequence(iSequence);
            return iSequence;
        }
        break;

    case DIE:
        iSequence = FuzzySearchSeq("die");
        if (iSequence != -1)
        {
            SetSequence(iSequence);
            return iSequence;
        }
        break;
    default:
        return -1;
    }
    return -1;
}

//增加的函数，得到名为seqname动画序列的持续时间numframe/fps
unsigned int MDLModel::GetSeqTime(char* seqname)
{
    int seqIndex = GetSequence(seqname);
    sequence_t	*pseqdesc;
    pseqdesc = (sequence_t *)((byte *)m_pmodelhdr + m_pmodelhdr->seqindex) + seqIndex;
    float millseqtime = pseqdesc->numframes/pseqdesc->fps*1000;
    return (unsigned int)millseqtime;
}

//增加的函数，得到当前帧的持续时间
unsigned int MDLModel::GetSeqTime()
{
    sequence_t	*pseqdesc;
    pseqdesc = (sequence_t *)((byte *)m_pmodelhdr + m_pmodelhdr->seqindex) + m_sequence;
    float millseqtime = pseqdesc->numframes/pseqdesc->fps*1000;
    return (unsigned int)millseqtime;
}

//得到包围盒x、y、z的最大值和最小值分别存储在min和max数组中
void MDLModel::ExtractBbox( float *mins, float *maxs )
{
    sequence_t	*pseqdesc;

    pseqdesc = (sequence_t *)((byte *)m_pmodelhdr + m_pmodelhdr->seqindex);

    mins[0] = pseqdesc[ m_sequence ].bbmin[0];
    mins[1] = pseqdesc[ m_sequence ].bbmin[1];
    mins[2] = pseqdesc[ m_sequence ].bbmin[2];

    maxs[0] = pseqdesc[ m_sequence ].bbmax[0];
    maxs[1] = pseqdesc[ m_sequence ].bbmax[1];
    maxs[2] = pseqdesc[ m_sequence ].bbmax[2];
}



void MDLModel::GetSequenceInfo( float *pflFrameRate, float *pflGroundSpeed )
{
    sequence_t	*pseqdesc;

    pseqdesc = (sequence_t *)((byte *)m_pmodelhdr + m_pmodelhdr->seqindex) + (int)m_sequence;

    if (pseqdesc->numframes > 1)
    {
        *pflFrameRate = 256 * pseqdesc->fps / (pseqdesc->numframes - 1);
        *pflGroundSpeed = sqrt( pseqdesc->linearmovement[0]*pseqdesc->linearmovement[0]+ pseqdesc->linearmovement[1]*pseqdesc->linearmovement[1]+ pseqdesc->linearmovement[2]*pseqdesc->linearmovement[2] );
        *pflGroundSpeed = *pflGroundSpeed * pseqdesc->fps / (pseqdesc->numframes - 1);
    }
    else
    {
        *pflFrameRate = 256.0;
        *pflGroundSpeed = 0.0;
    }
}

//设置控制器
float MDLModel::SetController( int iController, float flValue )
{
    bonecontroller_t	*pbonecontroller = (bonecontroller_t *)((byte *)m_pmodelhdr + m_pmodelhdr->bonecontrollerindex);

    // find first controller that matches the index
    int i;
    for (i = 0; i < m_pmodelhdr->numbonecontrollers; i++, pbonecontroller++)
    {
        if (pbonecontroller->index == iController)
            break;
    }
    if (i >= m_pmodelhdr->numbonecontrollers)
        return flValue;

    // wrap 0..360 if it's a rotational controller
    if (pbonecontroller->type & (MODEL_XR | MODEL_YR | MODEL_ZR))
    {
        // ugly hack, invert value if end < start
        if (pbonecontroller->end < pbonecontroller->start)
            flValue = -flValue;

        // does the controller not wrap?
        if (pbonecontroller->start + 359.0 >= pbonecontroller->end)
        {
            if (flValue > ((pbonecontroller->start + pbonecontroller->end) / 2.0) + 180)
                flValue = flValue - 360;
            if (flValue < ((pbonecontroller->start + pbonecontroller->end) / 2.0) - 180)
                flValue = flValue + 360;
        }
        else
        {
            if (flValue > 360)
                flValue = flValue - (int)(flValue / 360.0) * 360.0;
            else if (flValue < 0)
                flValue = flValue + (int)((flValue / -360.0) + 1) * 360.0;
        }
    }

    int setting = 255 * (flValue - pbonecontroller->start) / (pbonecontroller->end - pbonecontroller->start);

    if (setting < 0) setting = 0;
    if (setting > 255) setting = 255;
    m_controller[iController] = setting;

    return setting * (1.0 / 255.0) * (pbonecontroller->end - pbonecontroller->start) + pbonecontroller->start;
}


float MDLModel::SetMouth( float flValue )
{
    bonecontroller_t	*pbonecontroller = (bonecontroller_t *)((byte *)m_pmodelhdr + m_pmodelhdr->bonecontrollerindex);

    // find first controller that matches the mouth
    for (int i = 0; i < m_pmodelhdr->numbonecontrollers; i++, pbonecontroller++)
    {
        if (pbonecontroller->index == 4)
            break;
    }

    // wrap 0..360 if it's a rotational controller
    if (pbonecontroller->type & (MODEL_XR | MODEL_YR | MODEL_ZR))
    {
        // ugly hack, invert value if end < start
        if (pbonecontroller->end < pbonecontroller->start)
            flValue = -flValue;

        // does the controller not wrap?
        if (pbonecontroller->start + 359.0 >= pbonecontroller->end)
        {
            if (flValue > ((pbonecontroller->start + pbonecontroller->end) / 2.0) + 180)
                flValue = flValue - 360;
            if (flValue < ((pbonecontroller->start + pbonecontroller->end) / 2.0) - 180)
                flValue = flValue + 360;
        }
        else
        {
            if (flValue > 360)
                flValue = flValue - (int)(flValue / 360.0) * 360.0;
            else if (flValue < 0)
                flValue = flValue + (int)((flValue / -360.0) + 1) * 360.0;
        }
    }

    int setting = 64 * (flValue - pbonecontroller->start) / (pbonecontroller->end - pbonecontroller->start);

    if (setting < 0) setting = 0;
    if (setting > 64) setting = 64;
    m_mouth = setting;

    return setting * (1.0 / 64.0) * (pbonecontroller->end - pbonecontroller->start) + pbonecontroller->start;
}


float MDLModel::SetBlending( int iBlender, float flValue )
{
    sequence_t	*pseqdesc;

    pseqdesc = (sequence_t *)((byte *)m_pmodelhdr + m_pmodelhdr->seqindex) + (int)m_sequence;

    if (pseqdesc->blendtype[iBlender] == 0)
        return flValue;

    if (pseqdesc->blendtype[iBlender] & (MODEL_XR | MODEL_YR | MODEL_ZR))
    {
        // ugly hack, invert value if end < start
        if (pseqdesc->blendend[iBlender] < pseqdesc->blendstart[iBlender])
            flValue = -flValue;

        // does the controller not wrap?
        if (pseqdesc->blendstart[iBlender] + 359.0 >= pseqdesc->blendend[iBlender])
        {
            if (flValue > ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0) + 180)
                flValue = flValue - 360;
            if (flValue < ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0) - 180)
                flValue = flValue + 360;
        }
    }

    int setting = 255 * (flValue - pseqdesc->blendstart[iBlender]) / (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]);

    if (setting < 0) setting = 0;
    if (setting > 255) setting = 255;

    m_blending[iBlender] = setting;

    return setting * (1.0 / 255.0) * (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]) + pseqdesc->blendstart[iBlender];
}



int MDLModel::SetBodygroup( int iGroup, int iValue )
{
    if (iGroup > m_pmodelhdr->numbodyparts)
        return -1;

    bodyparts_t *pbodypart = (bodyparts_t *)((byte *)m_pmodelhdr + m_pmodelhdr->bodypartindex) + iGroup;

    int iCurrent = (m_bodynum / pbodypart->base) % pbodypart->nummodels;

    if (iValue >= pbodypart->nummodels)
        return iCurrent;

    m_bodynum = (m_bodynum - (iCurrent * pbodypart->base) + (iValue * pbodypart->base));

    return iValue;
}


int MDLModel::SetSkin( int iValue )
{
    if (iValue < m_pmodelhdr->numskinfamilies)
    {
        return m_skinnum;
    }

    m_skinnum = iValue;

    return iValue;
}