void StartMotors(void)
{
if(statusX.running == TRUE)
{
StartX();
}
if(statusY.running == TRUE)
{
StartY();
}
if(statusZ.running == TRUE)
{
StartZ();
}
}
void FEditorCommonDrawHelper::DrawOldGrid(const FSceneView* View,FPrimitiveDrawInterface* PDI)
{
ESceneDepthPriorityGroup eDPG = (ESceneDepthPriorityGroup)DepthPriorityGroup;
bool bIsPerspective = ( View->ViewMatrices.ProjMatrix.M[3][3] < 1.0f );
// Draw 3D perspective grid
if( bIsPerspective)
{
// @todo: Persp grid should be changed to be adaptive and use same settings as ortho grid, including grid interval!
const int32 RangeInCells = NumCells / 2;
const int32 MajorLineInterval = NumCells / 8;
const int32 NumLines = NumCells + 1;
const int32 AxesIndex = NumCells / 2;
for( int32 LineIndex = 0; LineIndex < NumLines; ++LineIndex )
{
bool bIsMajorLine = ( ( LineIndex - RangeInCells ) % MajorLineInterval ) == 0;
FVector A,B;
A.X=(PerspectiveGridSize/4.f)*(-1.0+2.0*LineIndex/NumCells); B.X=A.X;
A.Y=(PerspectiveGridSize/4.f); B.Y=-(PerspectiveGridSize/4.f);
A.Z=0.0; B.Z=0.0;
FColor LineColor;
float LineThickness = 0.f;
if ( LineIndex==AxesIndex )
{
LineColor = GridColorAxis;
LineThickness = AxesLineThickness;
}
else if ( bIsMajorLine )
{
LineColor = GridColorMajor;
}
else
{
LineColor = GridColorMinor;
}
PDI->DrawLine(A,B,LineColor,eDPG, LineThickness, GridDepthBias);
A.Y=A.X; B.Y=B.X;
A.X=(PerspectiveGridSize/4.f); B.X=-(PerspectiveGridSize/4.f);
PDI->DrawLine(A,B,LineColor,eDPG, LineThickness, GridDepthBias);
}
}
// Draw ortho grid.
else
{
const bool bIsOrthoXY = ( FMath::Abs(View->ViewMatrices.ViewMatrix.M[2][2]) > 0.0f );
const bool bIsOrthoXZ = ( FMath::Abs(View->ViewMatrices.ViewMatrix.M[1][2]) > 0.0f );
const bool bIsOrthoYZ = ( FMath::Abs(View->ViewMatrices.ViewMatrix.M[0][2]) > 0.0f );
FLinearColor AxisColors[3];
GetAxisColors(AxisColors, false);
if( bIsOrthoXY )
{
FVector StartY( 0.0f, +HALF_WORLD_MAX1, -HALF_WORLD_MAX );
FVector EndY( 0.0f, -HALF_WORLD_MAX1, -HALF_WORLD_MAX );
FVector StartX( +HALF_WORLD_MAX1, 0.0f, -HALF_WORLD_MAX );
FVector EndX( -HALF_WORLD_MAX1, 0.0f, -HALF_WORLD_MAX );
DrawGridSection( GEditor->GetGridSize(), &StartY, &EndY, &StartY.X, &EndY.X, 0, View, PDI);
DrawGridSection( GEditor->GetGridSize(), &StartX, &EndX, &StartX.Y, &EndX.Y, 1, View, PDI);
DrawOriginAxisLine( &StartY, &EndY, &StartY.X, &EndY.X, View, PDI, AxisColors[1] );
DrawOriginAxisLine( &StartX, &EndX, &StartX.Y, &EndX.Y, View, PDI, AxisColors[0] );
}
else if( bIsOrthoXZ )
{
FVector StartZ( 0.0f, -HALF_WORLD_MAX, +HALF_WORLD_MAX1 );
FVector EndZ( 0.0f, -HALF_WORLD_MAX, -HALF_WORLD_MAX1 );
FVector StartX( +HALF_WORLD_MAX1, -HALF_WORLD_MAX, 0.0f );
FVector EndX( -HALF_WORLD_MAX1, -HALF_WORLD_MAX, 0.0f );
DrawGridSection( GEditor->GetGridSize(), &StartZ, &EndZ, &StartZ.X, &EndZ.X, 0, View, PDI);
DrawGridSection( GEditor->GetGridSize(), &StartX, &EndX, &StartX.Z, &EndX.Z, 2, View, PDI);
DrawOriginAxisLine( &StartZ, &EndZ, &StartZ.X, &EndZ.X, View, PDI, AxisColors[2] );
DrawOriginAxisLine( &StartX, &EndX, &StartX.Z, &EndX.Z, View, PDI, AxisColors[0] );
}
else if( bIsOrthoYZ )
{
FVector StartZ( +HALF_WORLD_MAX, 0.0f, +HALF_WORLD_MAX1 );
FVector EndZ( +HALF_WORLD_MAX, 0.0f, -HALF_WORLD_MAX1 );
FVector StartY( +HALF_WORLD_MAX, +HALF_WORLD_MAX1, 0.0f );
FVector EndY( +HALF_WORLD_MAX, -HALF_WORLD_MAX1, 0.0f );
DrawGridSection( GEditor->GetGridSize(), &StartZ, &EndZ, &StartZ.Y, &EndZ.Y, 1, View, PDI);
DrawGridSection( GEditor->GetGridSize(), &StartY, &EndY, &StartY.Z, &EndY.Z, 2, View, PDI);
DrawOriginAxisLine( &StartZ, &EndZ, &StartZ.Y, &EndZ.Y, View, PDI, AxisColors[2] );
DrawOriginAxisLine( &StartY, &EndY, &StartY.Z, &EndY.Z, View, PDI, AxisColors[1] );
}
if( bDrawKillZ && ( bIsOrthoXZ || bIsOrthoYZ ) && GWorld->GetWorldSettings()->bEnableWorldBoundsChecks )
{
float KillZ = GWorld->GetWorldSettings()->KillZ;
PDI->DrawLine( FVector(-HALF_WORLD_MAX,0,KillZ), FVector(HALF_WORLD_MAX,0,KillZ), FColor(255,0,0), SDPG_Foreground );
PDI->DrawLine( FVector(0,-HALF_WORLD_MAX,KillZ), FVector(0,HALF_WORLD_MAX,KillZ), FColor(255,0,0), SDPG_Foreground );
}
}
// Draw orthogonal worldframe.
if(bDrawWorldBox)
{
DrawWireBox(PDI, FBox( FVector(-HALF_WORLD_MAX1,-HALF_WORLD_MAX1,-HALF_WORLD_MAX1),FVector(HALF_WORLD_MAX1,HALF_WORLD_MAX1,HALF_WORLD_MAX1) ), GEngine->C_WorldBox, eDPG );
}
}
/*
-----------------------------------------------------------------------
-----------------------------------------------------------------------
*/
void CTraceContainer::DrawCPU(const TRect& aRect, CWindowGc& gc) const
{
if(iMaskImg)
{
if(iMaskImg->Bitmap() && iMaskImg->Mask())
{
if(iMaskImg->Bitmap()->Handle() && iMaskImg->Mask()->Handle())
{
TSize ButtonSiz(iMaskImg->Bitmap()->SizeInPixels());
gc.DrawBitmapMasked(aRect,iMaskImg->Bitmap(),TRect(0,0,ButtonSiz.iWidth,ButtonSiz.iHeight),iMaskImg->Mask(),EFalse);
}
}
}
gc.SetPenColor(KRgbBlack);
gc.DrawLine(aRect.iTl,TPoint(aRect.iTl.iX,aRect.iBr.iY));
gc.DrawLine(aRect.iTl,TPoint(aRect.iBr.iX,aRect.iTl.iY));
gc.DrawLine(aRect.iBr,TPoint(aRect.iTl.iX,aRect.iBr.iY));
gc.DrawLine(aRect.iBr,TPoint(aRect.iBr.iX,aRect.iTl.iY));
TInt Prosentages(0);
if(iArray.Count() && iMaxCpuCount)
{
if(iArray[iArray.Count() - 1])
{
Prosentages = ((iArray[iArray.Count() - 1]->iCpuLoad * 100) / iMaxCpuCount);
Prosentages = (100 - Prosentages);
}
}
TInt SizPie = (aRect.Height() / 3);
//TPoint(aRect.iTl.iX, (aRect.iBr.iY - SizPie))
PieDrawer(gc,aRect.iTl,SizPie,Prosentages,ETrue);
gc.SetPenColor(KRgbRed);
TInt StartX(0);
if(iArray.Count() > aRect.Width())
{
StartX = (iArray.Count() - aRect.Width());
}
TPoint MePoint1(aRect.iTl.iX,aRect.iBr.iY);
TPoint MePoint2(aRect.iTl);
TInt Valll(0);
if(iMaxCpuCount > 0)
{
for(TInt i = StartX; i < iArray.Count(); i++)
{
if(iArray[i])
{
TUint32 Curr = (iMaxCpuCount - iArray[i]->iCpuLoad);
if(Curr < 0)
{
Curr = 0;
}
else if(iMaxCpuCount < Curr)
{
Curr = iMaxCpuCount;
}
Valll = ((aRect.Height() * Curr) / iMaxCpuCount);
}
MePoint2.iY = (aRect.iBr.iY - Valll);
if(StartX != 1)
{
gc.DrawLine(MePoint1,MePoint2);
}
MePoint1 = MePoint2;
MePoint2.iX = MePoint2.iX + 1;
}
}
}
