Method Update

GTE/Graphics/SkinController.cpp:29–110

}

bool SkinController::Update(double applicationTime)
{
    if (!Controller::Update(applicationTime))
    {
        return false;
    }

    if (mFirstUpdate)
    {
        mFirstUpdate = false;
        OnFirstUpdate();
    }

    if (mCanUpdate)
    {
        // The skin vertices are calculated in the bone world coordinate system,
        // so the visual's world transform must be the identity.
        auto visual = static_cast<Visual*>(mObject);
        visual->worldTransform = Transform<float>::Identity();
        visual->worldTransformIsCurrent = true;

        // Package the bone transformations into a std::vector to avoid the
        // expensive lock() calls in the inner loop of the position updates.
        std::vector<Matrix4x4<float>> worldTransforms(mNumBones);
        for (int32_t bone = 0; bone < mNumBones; ++bone)
        {
            worldTransforms[bone] = mBones[bone].lock()->worldTransform;
        }

        // Compute the skin vertex locations.  The typecasting to raw 'float'
        // pointers increases the frame rate dramatically, both in Debug and
        // Release builds.  Without this in Debug builds, the lack of inlining
        // of Vector4, Matrix4, std::array and std::vector operator[]
        // functions leads to a low frame rate.  Without this in Release
        // builds, the lack of a highly efficient implementation of operator[]
        // in std::array and std::vector leads to a low frame rate.  Running
        // on an Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz, the Debug frame rate
        // before the typecasting is 16 fps and after the typecasting is
        // 223 fps.  The Release frame rate before the typecasting is 2390 fps
        // and after the typecasting is 4170 fps (sync to vertical retrace is
        // turned off for these experiments).
        char* current = mPosition;
        float const* weights = mWeights.data();
        Vector4<float> const* offsets = mOffsets.data();
        for (int32_t vertex = 0; vertex < mNumVertices; ++vertex)
        {
            Matrix4x4<float> const* worldTransform = worldTransforms.data();
            float position[3] = { 0.0f, 0.0f, 0.0f };
            for (int32_t bone = 0; bone < mNumBones; ++bone, ++weights, ++offsets, ++worldTransform)
            {
                float weight = *weights;
                if (weight != 0.0f)
                {
                    float const* M = reinterpret_cast<float const*>(worldTransform);
                    float const* P = reinterpret_cast<float const*>(offsets);
#if defined (GTE_USE_VEC_MAT)
                    position[0] += weight * (M[0] * P[0] + M[4] * P[1] + M[8] * P[2] + M[12]);
                    position[1] += weight * (M[1] * P[0] + M[5] * P[1] + M[9] * P[2] + M[13]);