controlpanel.cpp

hl2 source code. Do not use it illegal.

		int i;
		mstudiobodyparts_t *pbodyparts = hdr->pBodypart(0);

		cBodypart->removeAll ();
		if (hdr->numbodyparts > 0)
		{
			for (i = 0; i < hdr->numbodyparts; i++)
				cBodypart->add (pbodyparts[i].pszName());

			cBodypart->select (0);

			cSubmodel->removeAll ();
			for (i = 0; i < pbodyparts[0].nummodels; i++)
			{
				char str[64];
				sprintf (str, "Submodel %d", i + 1);
				cSubmodel->add (str);
			}
			cSubmodel->select (0);
		}
	}
}



void
ControlPanel::setBodypart (int index)
{
	studiohdr_t *hdr = models->GetActiveStudioModel()->getStudioHeader ();
	if (hdr)
	{
		//cBodypart->setEn
		cBodypart->select (index);
		if (index < hdr->numbodyparts)
		{
			mstudiobodyparts_t *pbodyparts = hdr->pBodypart(0);
			cSubmodel->removeAll ();
		
			for (int i = 0; i < pbodyparts[index].nummodels; i++)
			{
				char str[64];
				sprintf (str, "Submodel %d", i + 1);
				cSubmodel->add (str);
			}
			cSubmodel->select (0);
			//models->GetActiveStudioModel()->SetBodygroup (index, 0);
		}
	}
}



void
ControlPanel::setSubmodel (int index)
{
	models->GetActiveStudioModel()->SetBodygroup (cBodypart->getSelectedIndex (), index);
	g_viewerSettings.submodels[cBodypart->getSelectedIndex ()] = index;
}



void
ControlPanel::initBoneControllers ()
{
	studiohdr_t *hdr = models->GetActiveStudioModel()->getStudioHeader ();
	if (hdr)
	{
		cController->setEnabled (hdr->numbonecontrollers > 0);
		slController->setEnabled (hdr->numbonecontrollers > 0);
		cController->removeAll ();

		mstudiobonecontroller_t *pbonecontrollers = hdr->pBonecontroller(0);
		for (int i = 0; i < hdr->numbonecontrollers; i++)
		{
			char str[32];
			sprintf (str, "Controller %d", pbonecontrollers[i].inputfield);
			cController->add (str);
		}

		if (hdr->numbonecontrollers > 0)
		{
			cController->select (0);
			slController->setRange (pbonecontrollers[0].start, pbonecontrollers[0].end);
			slController->setValue (0);
		}
	}
}



void
ControlPanel::setBoneController (int index)
{
	studiohdr_t *hdr = models->GetActiveStudioModel()->getStudioHeader ();
	if (hdr)
	{
		mstudiobonecontroller_t *pbonecontrollers = hdr->pBonecontroller(0);
		slController->setRange ( pbonecontrollers[index].start, pbonecontrollers[index].end);
		slController->setValue (0);
	}
}



void
ControlPanel::setBoneControllerValue (int index, float value)
{
	studiohdr_t *hdr = models->GetActiveStudioModel()->getStudioHeader ();
	if (hdr)
	{
		mstudiobonecontroller_t *pbonecontrollers = hdr->pBonecontroller(0);
		models->GetActiveStudioModel()->SetController (pbonecontrollers[index].inputfield, value);
	
		g_viewerSettings.controllers[index] = value;
	}
}



void
ControlPanel::initPoseParameters ()
{
	studiohdr_t *hdr = models->GetActiveStudioModel()->getStudioHeader ();
	if (hdr)
	{
		for (int i = 0; i < hdr->numposeparameters; i++)
		{
			setBlend( i, 0.0 );
		}
	}
}

void
ControlPanel::initSkins ()
{
	studiohdr_t *hdr = models->GetActiveStudioModel()->getStudioHeader ();
	if (hdr)
	{
		cSkin->setEnabled (hdr->numskinfamilies > 0);
		cSkin->removeAll ();

		for (int i = 0; i < hdr->numskinfamilies; i++)
		{
			char str[32];
			sprintf (str, "Skin %d", i + 1);
			cSkin->add (str);
		}

		cSkin->select (0);
		models->GetActiveStudioModel()->SetSkin (0);
		g_viewerSettings.skin = 0;
	}
}



void
ControlPanel::setModelInfo ()
{
	static char str[2048];
	studiohdr_t *hdr = models->GetActiveStudioModel()->getStudioHeader ();

	if (!hdr)
		return;

	int hbcount = 0;
	for ( int s = 0; s < hdr->numhitboxsets; s++ )
	{
		hbcount += hdr->iHitboxCount( s );
	}

	sprintf (str,
		"Bones: %d\n"
		"Bone Controllers: %d\n"
		"Hit Boxes: %d in %d sets\n"
		"Sequences: %d\n"
		"Sequence Groups: %d\n",
		hdr->numbones,
		hdr->numbonecontrollers,
		hbcount,
		hdr->numhitboxsets,
		hdr->numseq,
		hdr->numseqgroups
		);

	lModelInfo1->setLabel (str);

	sprintf (str,
		"Textures: %d\n"
		"Skin Families: %d\n"
		"Bodyparts: %d\n"
		"Attachments: %d\n"
		"Transitions: %d\n",
		hdr->numtextures,
		hdr->numskinfamilies,
		hdr->numbodyparts,
		hdr->numattachments,
		hdr->numtransitions);

	lModelInfo2->setLabel (str);
}



void
ControlPanel::initTextures ()
{
#if 0
	studiohdr_t *hdr = models->GetActiveStudioModel()->getTextureHeader ();
	if (hdr)
	{
		cTextures->removeAll ();
		mstudiotexture_t *ptextures = hdr->pTexture(0);
		for (int i = 0; i < hdr->numtextures; i++)
			cTextures->add ( hdr->pTexturename(i) );
		cTextures->select (0);
		g_viewerSettings.texture = 0;
		if (hdr->numtextures > 0)
			cbChrome->setChecked ((ptextures[0].flags & STUDIO_NF_CHROME) == STUDIO_NF_CHROME);
	}
#endif
}

void ControlPanel::CenterOnFace( void )
{
	if ( !models->GetActiveStudioModel() )
		return;

	studiohdr_t *hdr = models->GetActiveStudioModel()->getStudioHeader();
	if ( !hdr )
		return;

	setSpeed( 1.0f );

	setSequence( 0 );
	initPoseParameters( );

	g_viewerSettings.rot.Init();
	g_viewerSettings.trans.Init();

	Vector size;
	VectorSubtract( hdr->hull_max, hdr->hull_min, size );

	float eyeheight = hdr->hull_min.z + 0.9 * size.z;

	g_viewerSettings.trans.x = size.z * .6f;
	g_viewerSettings.trans.z += eyeheight;

	CUtlVector< StudioModel * > modellist;

	modellist.AddToTail( models->GetActiveStudioModel() );

	int i;
	if ( models->CountVisibleModels() > 0 )
	{
		modellist.RemoveAll();
		for ( i = 0; i < models->Count(); i++ )
		{
			if ( models->IsModelShownIn3DView( i ) )
			{
				modellist.AddToTail( models->GetStudioModel( i ) );
			}
		}
	}

	int modelcount = modellist.Count();
	int countover2 = modelcount / 2;
	int ydelta = GetModelGap();
	int yoffset = -countover2 * ydelta;
	for ( i = 0 ; i < modelcount; i++ )
	{
		if ( models->GetStudioHeader( i ) == hdr )
		{
			g_viewerSettings.trans.y = -yoffset;
		}
		yoffset += ydelta;
	}

	g_pMatSysWindow->redraw ();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : float
//-----------------------------------------------------------------------------
float ControlPanel::GetModelGap( void )
{
	return slModelGap->getValue();
}

void
ControlPanel::centerView ()
{
	if ( !models->GetActiveStudioModel() )
		return;

	Vector min, max;
	models->GetActiveStudioModel()->ExtractBbox (min, max);

	float dx = max[0] - min[0];
	float dy = max[1] - min[1];
	float dz = max[2] - min[2];
	float d = dx;
	if (dy > d)
		d = dy;
	if (dz > d)
		d = dz;
	g_viewerSettings.trans[0] = d * 1.0f;
	g_viewerSettings.trans[1] = 0;
	g_viewerSettings.trans[2] = min[2] + dz / 2;
	g_viewerSettings.rot[0] = 0.0f;
	g_viewerSettings.rot[1] = 0.0f;
	g_viewerSettings.rot[2] = 0.0f;
	g_viewerSettings.lightrot.x = 0.f;
	g_viewerSettings.lightrot.y = -180.0f;
	g_viewerSettings.lightrot.z = 0.0f;
	g_pMatSysWindow->redraw ();
}

bool ControlPanel::Close()
{
	int index = g_pExpressionClass->getSelectedIndex();
	CExpClass *cl = expressions->GetClass( index );
	if ( !cl )
		return true;

	return expressions->CloseClass( cl );

}

bool ControlPanel::Closeall() 
{
	bool retval = true;

	while ( expressions->GetNumClasses() > 0 )
	{
		CExpClass *cl = expressions->GetClass( 0 );
		if ( !cl )
			break;

		if ( !expressions->CloseClass( cl ) )
		{
			return false;
		}
	}
	return retval;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ControlPanel::Copy( void )
{
	g_pFlexPanel->CopyControllerSettings();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ControlPanel::Paste( void )
{
	g_pFlexPanel->PasteControllerSettings();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ControlPanel::Undo( void )
{
	CExpClass *active = expressions->GetActiveClass();
	if ( !active )
		return;
	int index = active->GetSelectedExpression();
	if ( index != -1 )
	{
		UndoExpression( index );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ControlPanel::Redo( void )
{
	CExpClass *active = expressions->GetActiveClass();
	if ( !active )
		return;
	int index = active->GetSelectedExpression();
	if ( index != -1 )
	{
		RedoExpression( index );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ControlPanel::UndoExpression( int index )
{
	if ( index == -1 )
		return;

	CExpClass *active = expressions->GetActiveClass();
	if ( !active )
		return;

	CExpression *exp = active->GetExpression( index );
	if ( exp )
	{
		exp->Undo();
		// Show the updated data
		active->SelectExpression( index );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ControlPanel::RedoExpression( int index )
{
	if ( index == -1 )
		return;
	
	CExpClass *active = expressions->GetActiveClass();
	if ( !active )
		return;

	CExpression *exp = active->GetExpression( index );
	if ( exp )
	{
		exp->Redo();
		// Show the updated data
		active->SelectExpression( index );
	}
}

void ControlPanel::DeleteExpressionOverride( int index )
{
	CExpClass *active = expressions->GetActiveClass();
	if ( !active )
		return;

	CExpression *exp = active->GetExpression( index );
	if ( !exp )
		return;

	if ( !exp->HasOverride() )
	{
		Assert( 0 );
		Con_Printf( "Expression %s has no override for model %s\n", exp->name, models->GetActiveModelName() );
		return;
	}

	CExpression *override = exp->GetOverride();
	if ( !override )
	{
		Assert( 0 );
		Con_Printf( "Expression %s has no override for model %s\n", exp->name, models->GetActiveModelName() );
		return;
	}

	// Remove from reference expression
	exp->SetOverride( NULL );

	// Now remove from overrides class
	CExpClass *oc = active->GetOverrideClass();
	if ( !oc )
	{
		Assert( 0 );
		Con_ColorPrintf( ERROR_R, ERROR_G, ERROR_B, "Class %s doesn't have any associated override class\n", active->GetName() );
		return;
	}

	Con_Printf( "Deleting override expression %s : %s\n", override->name, override->description );

	oc->DeleteExpression( override->name );

	// So overrides save when we save
	active->SetDirty( true );

	active->SelectExpression( index );
}

void ControlPanel::DeleteExpression( int index )
{
	CExpClass *active = expressions->GetActiveClass();
	if ( !active )
		return;

	CExpression *exp = active->GetExpression( index );
	if ( exp )
	{
		Con_Printf( "Deleting expression %s : %s\n", exp->name, exp->description );
			
		g_pFlexPanel->DeleteExpression( index );

		active->SelectExpression( max( 0, index - 1 ) );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : dt - 
//-----------------------------------------------------------------------------
void ControlPanel::Think( float dt )
{
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool ControlPanel::AllToolsDriveSpeech( void )
{
	return cbAllWindowsDriveSpeech->isChecked();
}