C++ ABrush::GetActorRotation方法代码示例

void UTexAlignerDefault::AlignSurf( ETexAlign InTexAlignType, UModel* InModel, FBspSurfIdx* InSurfIdx, FPoly* InPoly, FVector* InNormal )
{
	InPoly->Base = InPoly->Vertices[0];
	InPoly->TextureU = FVector::ZeroVector;
	InPoly->TextureV = FVector::ZeroVector;
	InPoly->Finalize( NULL, 0 );

	InPoly->TextureU *= UTile;
	InPoly->TextureV *= VTile;

	ABrush* Actor = InSurfIdx->Surf->Actor;
	const FVector PrePivot = Actor->GetPivotOffset();
	const FVector Location = Actor->GetActorLocation();
	const FRotator Rotation = Actor->GetActorRotation();
	const FVector Scale = Actor->GetActorScale();
	const FRotationMatrix RotMatrix(Rotation);

	FVector Base = RotMatrix.TransformVector((InPoly->Base - PrePivot) * Scale) + Location;
	FVector TextureU = RotMatrix.TransformVector(InPoly->TextureU / Scale);
	FVector TextureV = RotMatrix.TransformVector(InPoly->TextureV / Scale);

	InSurfIdx->Surf->pBase = FBSPOps::bspAddPoint(InModel, &Base, 0);
	InSurfIdx->Surf->vTextureU = FBSPOps::bspAddVector( InModel, &TextureU, 0);
	InSurfIdx->Surf->vTextureV = FBSPOps::bspAddVector( InModel, &TextureV, 0);
}

void UEditorEngine::polyUpdateMaster
(
	UModel*	Model,
	int32  	iSurf,
	int32		UpdateTexCoords
)
{
	FBspSurf &Surf = Model->Surfs[iSurf];
	ABrush* Actor = Surf.Actor;
	if( !Actor )
		return;

	UModel* Brush = Actor->Brush;
	check(Brush);

	FVector ActorLocation;
	FVector ActorPrePivot;
	FVector ActorScale;
	FRotator ActorRotation;

	if (Brush->bCachedOwnerTransformValid)
	{
		// Use transform cached when the geometry was last built, in case the current Actor transform has changed since then
		// (e.g. because Auto Update BSP is disabled)
		ActorLocation = Brush->OwnerLocationWhenLastBuilt;
		ActorPrePivot = Brush->OwnerPrepivotWhenLastBuilt;
		ActorScale = Brush->OwnerScaleWhenLastBuilt;
		ActorRotation = -Brush->OwnerRotationWhenLastBuilt;
	}
	else
	{
		// No cached owner transform, so use the current one
		ActorLocation = Actor->GetActorLocation();
		ActorPrePivot = Actor->GetPrePivot();
		ActorScale = Actor->GetActorScale();
		ActorRotation = -Actor->GetActorRotation();
	}

	for( int32 iEdPoly = Surf.iBrushPoly; iEdPoly < Brush->Polys->Element.Num(); iEdPoly++ )
	{
		FPoly& MasterEdPoly = Brush->Polys->Element[iEdPoly];
		if( iEdPoly==Surf.iBrushPoly || MasterEdPoly.iLink==Surf.iBrushPoly )
		{
			MasterEdPoly.Material  = Surf.Material;
			MasterEdPoly.PolyFlags = Surf.PolyFlags & ~(PF_NoEdit);

			if( UpdateTexCoords )
			{
				MasterEdPoly.Base = ActorRotation.RotateVector(Model->Points[Surf.pBase] - ActorLocation) / ActorScale + ActorPrePivot;
				MasterEdPoly.TextureU = ActorRotation.RotateVector(Model->Vectors[Surf.vTextureU]) * ActorScale;
				MasterEdPoly.TextureV = ActorRotation.RotateVector(Model->Vectors[Surf.vTextureV]) * ActorScale;
			}
		}
	}

	Model->InvalidSurfaces = true;
}

bool FEdModeGeometry::GetCustomDrawingCoordinateSystem( FMatrix& InMatrix, void* InData )
{
	if( GetSelectionState() == GSS_None )
	{
		return 0;
	}

	if( InData )
	{
		FGeomBase* GeomBase = static_cast<FGeomBase*>(InData);
		FGeomObject* GeomObject = GeomBase->GetParentObject();
		check(GeomObject != nullptr);
		ABrush* Brush = GeomObject->GetActualBrush();
		InMatrix = FRotationMatrix(GeomBase->GetNormal().Rotation()) * FRotationMatrix(Brush->GetActorRotation());
	}
	else
	{
		// If we don't have a specific geometry object to get the normal from
		// use the one that was last selected.

		for( int32 o = 0 ; o < GeomObjects.Num() ; ++o )
		{
			FGeomObject* go = GeomObjects[o];
			go->CompileSelectionOrder();

			if( go->SelectionOrder.Num() )
			{
				FGeomBase* GeomBase = go->SelectionOrder[go->SelectionOrder.Num() - 1];
				check(GeomBase != nullptr);
				FGeomObject* GeomObject = GeomBase->GetParentObject();
				check(GeomObject != nullptr);
				ABrush* Brush = GeomObject->GetActualBrush();
				InMatrix = FRotationMatrix( go->SelectionOrder[ go->SelectionOrder.Num()-1 ]->GetWidgetRotation() ) * FRotationMatrix(Brush->GetActorRotation());
				return 1;
			}
		}
	}

	return 0;
}