void
ControlPanel::initPoseParameters()
{
CStudioHdr *hdr = models->GetActiveStudioModel()->GetStudioHdr();
if (hdr)
{
for (int i = 0; i < hdr->GetNumPoseParameters(); i++)
{
setBlend( i, 0.0 );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Clear all pose parameters
//-----------------------------------------------------------------------------
void C_HL2MP_Player::InitializePoseParams( void )
{
m_headYawPoseParam = LookupPoseParameter( "head_yaw" );
GetPoseParameterRange( m_headYawPoseParam, m_headYawMin, m_headYawMax );
m_headPitchPoseParam = LookupPoseParameter( "head_pitch" );
GetPoseParameterRange( m_headPitchPoseParam, m_headPitchMin, m_headPitchMax );
CStudioHdr *hdr = GetModelPtr();
for ( int i = 0; i < hdr->GetNumPoseParameters() ; i++ )
{
SetPoseParameter( hdr, i, 0.0 );
}
}
int StudioModel::LookupPoseParameter( char const *szName )
{
CStudioHdr *pStudioHdr = GetStudioHdr();
if (!pStudioHdr)
return false;
for (int iParameter = 0; iParameter < pStudioHdr->GetNumPoseParameters(); iParameter++)
{
if (stricmp( szName, pStudioHdr->pPoseParameter( iParameter ).pszName() ) == 0)
{
return iParameter;
}
}
return -1;
}
void CASW_Dummy_Vehicle::SetNormalizedPoseParameter(int iParam, float fValue)
{
CStudioHdr *pStudioHdr = GetModelPtr();
if (!pStudioHdr)
return;
if (iParam < 0 || iParam >= pStudioHdr->GetNumPoseParameters())
return;
const mstudioposeparamdesc_t &Pose = pStudioHdr->pPoseParameter( iParam );
float diff = Pose.end - Pose.start;
SetPoseParameter(iParam, Pose.start + diff * fValue);
}
bool StudioModel::GetPoseParameterRange( int iParameter, float *pflMin, float *pflMax )
{
*pflMin = 0;
*pflMax = 0;
CStudioHdr *pStudioHdr = GetStudioHdr();
if (!pStudioHdr)
return false;
if (iParameter < 0 || iParameter >= pStudioHdr->GetNumPoseParameters())
return false;
const mstudioposeparamdesc_t &Pose = pStudioHdr->pPoseParameter( iParameter );
*pflMin = Pose.start;
*pflMax = Pose.end;
return true;
}
bool SEditModelRender::LoadModel( const char *localPath )
{
DestroyModel();
const model_t *mdl = modelinfo->FindOrLoadModel( localPath );
if ( !mdl )
return false;
Q_strcpy( m_szModelPath, localPath );
C_BaseFlex *pEnt = new C_BaseFlex();
pEnt->InitializeAsClientEntity( NULL,
#ifdef SWARM_DLL
false
#else
RENDER_GROUP_OPAQUE_ENTITY
#endif
);
MDLCACHE_CRITICAL_SECTION();
pEnt->SetModelPointer( mdl );
pEnt->Spawn();
pEnt->SetAbsAngles( vec3_angle );
pEnt->SetAbsOrigin( vec3_origin );
pEnt->AddEffects( EF_NODRAW | EF_NOINTERP );
pEnt->m_EntClientFlags |= ENTCLIENTFLAG_DONTUSEIK;
// leave it alone.
pEnt->RemoveFromLeafSystem();
cl_entitylist->RemoveEntity( pEnt->GetRefEHandle() );
pEnt->CollisionProp()->DestroyPartitionHandle();
CStudioHdr *pHdr = pEnt->GetModelPtr();
m_iNumPoseParams = pHdr ? pHdr->GetNumPoseParameters() : 0;
pModelInstance = pEnt;
return true;
}
float CAnimating::EdgeLimitPoseParameter( int iParameter, float flValue, float flBase )
{
CStudioHdr *pstudiohdr = GetModelPtr( );
if ( !pstudiohdr )
{
return flValue;
}
if (iParameter < 0 || iParameter >= pstudiohdr->GetNumPoseParameters())
{
return flValue;
}
const mstudioposeparamdesc_t &Pose = pstudiohdr->pPoseParameter( iParameter );
if (Pose.loop || Pose.start == Pose.end)
{
return flValue;
}
return RangeCompressor( flValue, Pose.start, Pose.end, flBase );
}
//-----------------------------------------------------------------------------
// Purpose: Render the weapon. Draw the Viewmodel if the weapon's being carried
// by this player, otherwise draw the worldmodel.
//-----------------------------------------------------------------------------
int C_BaseViewModel::DrawModel( int flags, const RenderableInstance_t &instance )
{
if ( !m_bReadyToDraw )
return 0;
if ( flags & STUDIO_RENDER )
{
// Determine blending amount and tell engine
float blend = (float)( instance.m_nAlpha / 255.0f );
// Totally gone
if ( blend <= 0.0f )
return 0;
// Tell engine
render->SetBlend( blend );
float color[3];
GetColorModulation( color );
render->SetColorModulation( color );
}
CMatRenderContextPtr pRenderContext( materials );
if ( ShouldFlipViewModel() )
pRenderContext->CullMode( MATERIAL_CULLMODE_CW );
int ret = 0;
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
C_BaseCombatWeapon *pWeapon = GetOwningWeapon();
// If the local player's overriding the viewmodel rendering, let him do it
if ( pPlayer && pPlayer->IsOverridingViewmodel() )
{
ret = pPlayer->DrawOverriddenViewmodel( this, flags, instance );
}
else if ( pWeapon && pWeapon->IsOverridingViewmodel() )
{
ret = pWeapon->DrawOverriddenViewmodel( this, flags, instance );
}
else
{
ret = BaseClass::DrawModel( flags, instance );
}
pRenderContext->CullMode( MATERIAL_CULLMODE_CCW );
// Now that we've rendered, reset the animation restart flag
if ( flags & STUDIO_RENDER )
{
if ( m_nOldAnimationParity != m_nAnimationParity )
{
m_nOldAnimationParity = m_nAnimationParity;
}
// Tell the weapon itself that we've rendered, in case it wants to do something
if ( pWeapon )
{
pWeapon->ViewModelDrawn( this );
}
if ( vm_debug.GetBool() )
{
MDLCACHE_CRITICAL_SECTION();
int line = 16;
CStudioHdr *hdr = GetModelPtr();
engine->Con_NPrintf( line++, "%s: %s(%d), cycle: %.2f cyclerate: %.2f playbackrate: %.2f\n",
(hdr)?hdr->pszName():"(null)",
GetSequenceName( GetSequence() ),
GetSequence(),
GetCycle(),
GetSequenceCycleRate( hdr, GetSequence() ),
GetPlaybackRate()
);
if ( hdr )
{
for( int i=0; i < hdr->GetNumPoseParameters(); ++i )
{
const mstudioposeparamdesc_t &Pose = hdr->pPoseParameter( i );
engine->Con_NPrintf( line++, "pose_param %s: %f",
Pose.pszName(), GetPoseParameter( i ) );
}
}
// Determine blending amount and tell engine
float blend = (float)( instance.m_nAlpha / 255.0f );
float color[3];
GetColorModulation( color );
engine->Con_NPrintf( line++, "blend=%f, color=%f,%f,%f", blend, color[0], color[1], color[2] );
engine->Con_NPrintf( line++, "GetRenderMode()=%d", GetRenderMode() );
engine->Con_NPrintf( line++, "m_nRenderFX=0x%8.8X", GetRenderFX() );
color24 c = GetRenderColor();
unsigned char a = GetRenderAlpha();
engine->Con_NPrintf( line++, "rendercolor=%d,%d,%d,%d", c.r, c.g, c.b, a );
engine->Con_NPrintf( line++, "origin=%f, %f, %f", GetRenderOrigin().x, GetRenderOrigin().y, GetRenderOrigin().z );
engine->Con_NPrintf( line++, "angles=%f, %f, %f", GetRenderAngles()[0], GetRenderAngles()[1], GetRenderAngles()[2] );
if ( IsEffectActive( EF_NODRAW ) )
{
engine->Con_NPrintf( line++, "EF_NODRAW" );
}
}
}
return ret;
}
void IFaceposerModels::CFacePoserModel::CreateNewBitmap( char const *pchBitmapFilename, int sequence, int nSnapShotSize, bool bZoomInOnFace, CExpression *pExpression, mxbitmapdata_t *bitmap )
{
MatSysWindow *pWnd = g_pMatSysWindow;
if ( !pWnd )
return;
StudioModel *model = m_pModel;
if ( !model )
return;
CStudioHdr *hdr = model->GetStudioHdr();
if ( !hdr )
return;
if ( sequence < 0 || sequence >= hdr->GetNumSeq() )
return;
mstudioseqdesc_t &seqdesc = hdr->pSeqdesc( sequence );
Con_ColorPrintf( FILE_COLOR, "Creating bitmap %s for sequence '%s'\n", pchBitmapFilename, seqdesc.pszLabel() );
model->ClearOverlaysSequences();
int iLayer = model->GetNewAnimationLayer();
model->SetOverlaySequence( iLayer, sequence, 1.0 );
model->SetOverlayRate( iLayer, FindPoseCycle( model, sequence ), 0.0 );
for (int i = 0; i < hdr->GetNumPoseParameters(); i++)
{
model->SetPoseParameter( i, 0.0 );
}
float flexValues[ GLOBAL_STUDIO_FLEX_CONTROL_COUNT ] = { 0 };
if ( pExpression )
{
float *settings = pExpression->GetSettings();
float *weights = pExpression->GetWeights();
// Save existing settings from model
for ( LocalFlexController_t i = LocalFlexController_t(0); i < hdr->numflexcontrollers(); ++i )
{
int j = hdr->pFlexcontroller( i )->localToGlobal;
if ( j == -1 )
continue;
flexValues[ i ] = model->GetFlexController( i );
// Set Value from passed in settings
model->SetFlexController( i, settings[ j ] * weights[ j ] );
}
}
model->ClearLookTargets( );
QAngle oldrot, oldLight;
Vector oldtrans;
VectorCopy( model->m_angles, oldrot );
VectorCopy( model->m_origin, oldtrans );
VectorCopy( g_viewerSettings.lightrot, oldLight );
model->m_angles.Init();
model->m_origin.Init();
g_viewerSettings.lightrot.Init();
g_viewerSettings.lightrot.y = -180;
bool bSaveGround = g_viewerSettings.showGround;
g_viewerSettings.showGround = false;
if ( bZoomInOnFace )
{
Vector size;
VectorSubtract( hdr->hull_max(), hdr->hull_min(), size );
float eyeheight = hdr->hull_min().z + 0.9 * size.z;
// float width = ( size.x + size.y ) / 2.0f;
model->m_origin.x = size.z * .6f;
if ( hdr->GetNumAttachments() > 0 )
{
for (int i = 0; i < hdr->GetNumAttachments(); i++)
{
const mstudioattachment_t &attachment = hdr->pAttachment( i );
int iBone = hdr->GetAttachmentBone( i );
if ( Q_stricmp( attachment.pszName(), "eyes" ) )
continue;
mstudiobone_t *bone = hdr->pBone( iBone );
if ( !bone )
continue;
matrix3x4_t boneToPose;
MatrixInvert( bone->poseToBone, boneToPose );
matrix3x4_t attachmentPoseToLocal;
ConcatTransforms( boneToPose, attachment.local, attachmentPoseToLocal );
Vector localSpaceEyePosition;
VectorITransform( vec3_origin, attachmentPoseToLocal, localSpaceEyePosition );
// Not sure why this must be negative?
eyeheight = -localSpaceEyePosition.z + hdr->hull_min().z;
break;
}
}
KeyValues *seqKeyValues = new KeyValues("");
if ( seqKeyValues->LoadFromBuffer( model->GetFileName( ), model->GetKeyValueText( sequence ) ) )
{
// Do we have a build point section?
KeyValues *pkvAllFaceposer = seqKeyValues->FindKey("faceposer");
if ( pkvAllFaceposer )
{
float flEyeheight = pkvAllFaceposer->GetFloat( "eye_height", -9999.0f );
if ( flEyeheight != -9999.0f )
{
eyeheight = flEyeheight;
}
}
}
model->m_origin.z += eyeheight;
}
else
{
Vector mins, maxs;
model->ExtractBbox(mins, maxs);
Vector size;
VectorSubtract( maxs, mins, size );
float maxdim = size.x;
if ( size.y > maxdim )
maxdim = size.y;
if ( size.z > maxdim )
maxdim = size.z;
float midpoint = mins.z + 0.5 * size.z;
model->m_origin.x = 3 * maxdim;
model->m_origin.z += midpoint;
}
pWnd->SuppressResize( true );
RECT rcClient;
HWND wnd = (HWND)pWnd->getHandle();
WINDOWPLACEMENT wp;
GetWindowPlacement( wnd, &wp );
GetClientRect( wnd, &rcClient );
MoveWindow( wnd, 0, 0, nSnapShotSize + 16, nSnapShotSize + 16, TRUE );
// Snapshots are taken of the back buffer;
// we need to render to the back buffer but not move it to the front
pWnd->SuppressBufferSwap( true );
pWnd->redraw();
pWnd->SuppressBufferSwap( false );
// make it square, assumes w > h
char fullpath[ 512 ];
Q_snprintf( fullpath, sizeof( fullpath ), "%s%s", GetGameDirectory(), pchBitmapFilename );
pWnd->TakeSnapshotRect( fullpath, 0, 0, nSnapShotSize, nSnapShotSize );
// Move back to original position
SetWindowPlacement( wnd, &wp );
pWnd->SuppressResize( false );
VectorCopy( oldrot, model->m_angles );
VectorCopy( oldtrans, model->m_origin );
VectorCopy( oldLight, g_viewerSettings.lightrot );
g_viewerSettings.showGround = bSaveGround;
if ( pExpression )
{
// Save existing settings from model
for ( LocalFlexController_t i = LocalFlexController_t(0); i < hdr->numflexcontrollers(); ++i )
{
int j = hdr->pFlexcontroller( i )->localToGlobal;
if ( j == -1 )
continue;
model->SetFlexController( i, flexValues[ i ] );
}
}
model->ClearOverlaysSequences();
if ( bitmap->valid )
{
DeleteObject( bitmap->image );
bitmap->image = 0;
bitmap->valid = false;
}
LoadBitmapFromFile( pchBitmapFilename, *bitmap );
}