Esempio n. 1
0
 /// \brief
 ///   Sets the bone mask to be used with this bone
 ///
 /// \param bm
 ///   Bone mask to set
 inline void             SetBoneMask(BoneMask bm) throw()                        { m_bm = BoneMask(bm&VGBone::FULL_BONE_MASK); }
Esempio n. 2
0
void CDmeMDL::SetUpBones( CStudioHdr &studioHdr, const matrix3x4_t& shapeToWorld, int nMaxBoneCount, matrix3x4_t *pBoneToWorld )
{
	// Default to middle of the pose parameter range
	float pPoseParameter[MAXSTUDIOPOSEPARAM];
	for ( int i = 0; i < MAXSTUDIOPOSEPARAM; ++i )
	{
		pPoseParameter[i] = 0.5f;
	}

	int nFrameCount = Studio_MaxFrame( &studioHdr, m_nSequence, pPoseParameter );
	if ( nFrameCount == 0 )
	{
		nFrameCount = 1;
	}
	float flCycle = ( m_flTime * m_flPlaybackRate ) / nFrameCount;

	// FIXME: We're always wrapping; may want to determing if we should clamp
	flCycle -= (int)(flCycle);

	Vector		pos[MAXSTUDIOBONES];
	Quaternion	q[MAXSTUDIOBONES];

	InitPose( &studioHdr, pos, q, BoneMask( ) );
	AccumulatePose( &studioHdr, NULL, pos, q, m_nSequence, flCycle, pPoseParameter, BoneMask( ), 1.0f, m_flTime );

	// FIXME: Try enabling this?
//	CalcAutoplaySequences( pStudioHdr, NULL, pos, q, pPoseParameter, BoneMask( ), flTime );

	// Root transform
	matrix3x4_t rootToWorld, temp;

	// Rotate the root transform to make it align with DMEs
	// DMEs up vector is the y axis
	if ( !m_bDrawInEngine )
	{
		matrix3x4_t engineToDme;
		EngineToDmeMatrix( engineToDme );
		ConcatTransforms( engineToDme, shapeToWorld, rootToWorld );
	}
	else
	{
		MatrixCopy( shapeToWorld, rootToWorld );
	}

	if ( nMaxBoneCount > studioHdr.numbones() )
	{
		nMaxBoneCount = studioHdr.numbones();
	}

	for ( int i = 0; i < nMaxBoneCount; i++ ) 
	{
		// If it's not being used, fill with NAN for errors
#ifdef _DEBUG
		if ( !(studioHdr.pBone( i )->flags & BoneMask()))
		{
			int j, k;
			for (j = 0; j < 3; j++)
			{
				for (k = 0; k < 4; k++)
				{
					pBoneToWorld[i][j][k] = VEC_T_NAN;
				}
			}
			continue;
		}
#endif

		matrix3x4_t boneMatrix;
		QuaternionMatrix( q[i], boneMatrix );
		MatrixSetColumn( pos[i], 3, boneMatrix );

		if (studioHdr.pBone(i)->parent == -1) 
		{
			ConcatTransforms( rootToWorld, boneMatrix, pBoneToWorld[i] );
		} 
		else 
		{
			ConcatTransforms( pBoneToWorld[ studioHdr.pBone(i)->parent ], boneMatrix, pBoneToWorld[i] );
		}
	}
}
Esempio n. 3
0
//-----------------------------------------------------------------------------------
void TheGame::Render() const
{
    ENSURE_NO_MATRIX_STACK_SIDE_EFFECTS(Renderer::instance->m_viewStack);
    ENSURE_NO_MATRIX_STACK_SIDE_EFFECTS(Renderer::instance->m_projStack);
    Begin3DPerspective();
    RenderCoolStuff();
    RenderAxisLines();
    if (g_loadedSkeleton && m_showSkeleton)
    {
        if (g_loadedMotion)
        {
            BoneMask TotalMask = BoneMask(g_loadedSkeleton->GetJointCount());
            TotalMask.SetAllBonesTo(1.0f);
            g_loadedMotion->ApplyMotionToSkeleton(g_loadedSkeleton, (float)GetCurrentTimeSeconds(), TotalMask);
            if (g_loadedSkeleton->m_joints)
            {
                delete g_loadedSkeleton->m_joints->m_mesh;
                delete g_loadedSkeleton->m_joints->m_material;
                delete g_loadedSkeleton->m_joints;
                g_loadedSkeleton->m_joints = nullptr;
            }
            if (g_loadedSkeleton->m_bones)
            {
                delete g_loadedSkeleton->m_bones->m_mesh;
                delete g_loadedSkeleton->m_bones->m_material;
                delete g_loadedSkeleton->m_bones;
                g_loadedSkeleton->m_bones = nullptr;
            }
        }
        else if (g_loadedMotions)
        {
            BoneMask upperHalfMask = BoneMask(g_loadedSkeleton->GetJointCount());
            upperHalfMask.SetAllBonesTo(1.0f);
            for (int i = 0; i < 9; ++i)
            {
                upperHalfMask.boneMasks[i] = 0.0f;
            }
            BoneMask lowerHalfMask = BoneMask(g_loadedSkeleton->GetJointCount());
            lowerHalfMask.SetAllBonesTo(0.0f);
            for (int i = 0; i < 9; ++i)
            {
                lowerHalfMask.boneMasks[i] = 1.0f;
            }
            g_loadedMotions->at(0)->ApplyMotionToSkeleton(g_loadedSkeleton, (float)GetCurrentTimeSeconds(), upperHalfMask);
            g_loadedMotions->at(1)->ApplyMotionToSkeleton(g_loadedSkeleton, (float)GetCurrentTimeSeconds(), lowerHalfMask);
            if (g_loadedSkeleton->m_joints)
            {
                delete g_loadedSkeleton->m_joints->m_mesh;
                delete g_loadedSkeleton->m_joints->m_material;
                delete g_loadedSkeleton->m_joints;
                g_loadedSkeleton->m_joints = nullptr;
            }
            if (g_loadedSkeleton->m_bones)
            {
                delete g_loadedSkeleton->m_bones->m_mesh;
                delete g_loadedSkeleton->m_bones->m_material;
                delete g_loadedSkeleton->m_bones;
                g_loadedSkeleton->m_bones = nullptr;
            }
        }
        g_loadedSkeleton->Render();
    }
    End3DPerspective();
    Console::instance->Render();
}