C++ (Cpp) Rotator 예제들

예제 #1

파일: DraggableMoveTile.cpp 프로젝트: pokelege/ProjectTap_Code

void ADraggableMoveTile::UpdateIndicator()
{
	auto indicatorBody = indicatorParticle->EmitterInstances[0];
	auto Z_offset = FVector(0.0f, 0.0f, 30.0f);
	auto sourcePoint = GetActorLocation() + Z_offset;
	auto targetPoint = newGoalPos;
	targetPoint += Z_offset;

	if (isSelected)
	{
		arrowMeshComponent->SetHiddenInGame(false);
		indicatorBody->SetBeamSourcePoint(sourcePoint, 0);
		indicatorBody->SetBeamTargetPoint(targetPoint, 0);
		arrowMeshComponent->SetWorldLocation(targetPoint);
		auto rot = FRotationMatrix::MakeFromX(targetPoint - sourcePoint);
		arrowMeshComponent->SetWorldRotation(rot.Rotator());
	}
	else
	{
		indicatorBody->SetBeamSourcePoint(GetActorLocation(), 0);
		indicatorBody->SetBeamTargetPoint(GetActorLocation(), 0);
		arrowMeshComponent->SetWorldLocation(GetActorLocation());
		arrowMeshComponent->SetWorldRotation(FRotationMatrix::Identity.Rotator());
		arrowMeshComponent->SetHiddenInGame(true);
	}

	auto indicatorBodyMaterial = indicatorParticle->CreateDynamicMaterialInstance(0);
	indicatorBodyMaterial->SetScalarParameterValue(TEXT("IsDestinationValid"), canSnap && !destinationOccupied ? 1.0f : 0.0f);

	auto arrowMaterial = arrowMeshComponent->CreateDynamicMaterialInstance(0);
	arrowMaterial->SetScalarParameterValue(TEXT("IsDestinationValid"), canSnap && !destinationOccupied ? 1.0f : 0.0f);
}

예제 #2

파일: Model.cpp 프로젝트: genxinzou/svn-spring-archive

void MdlObject::ApplyTransform (bool removeRotation, bool removeScaling, bool removePosition)
{
	Matrix mat;
	mat.identity();
	if (removeScaling) {
		Matrix scaling;
		scaling.scale(scale);
		scale.set(1,1,1);
		mat = scaling;
	}
	if (removeRotation) {
		Matrix rotationMatrix;
		rotation.ToMatrix(rotationMatrix);
		mat *= rotationMatrix;
		rotation = Rotator();
	}
	
	if (removePosition) {
		mat.t(0) = position.x;
		mat.t(1) = position.y;
		mat.t(2) = position.z;
		position=Vector3();
	}
	Transform(mat);
}

예제 #3

파일: Editor.cpp 프로젝트: genxinzou/svn-spring-archive

void EditorUI::menuObjectResetScaleRot()
{
    vector<MdlObject*> sel=model->GetSelectedObjects();
    for (int a=0; a<sel.size(); a++) 	{
        sel[a]->rotation=Rotator();
        sel[a]->scale.set(1,1,1);
    }
    Update();
}

예제 #4

파일: Editor.cpp 프로젝트: Neoniet/upspring

void EditorUI::menuObjectResetScaleRot()
{
	vector<MdlObject*> sel=model->GetSelectedObjects();
	for (unsigned int a=0;a<sel.size();a++) 	{
        sel[a]->rotation=Rotator();
		sel[a]->scale.set(1,1,1);
	}
	BACKUP_POINT("Reset scale+rotation of selected objects");
	Update();
}

예제 #5

파일: MagnetTile.cpp 프로젝트: pokelege/ProjectTap_Code

void AMagnetTile::SpawnSubMagnet( const FVector& start ,
								  const FVector& dir )
{
	auto rotation = FRotationMatrix::MakeFromX( dir );
	//offset
	auto newPos = start + dir * 20.0f;
	subMagnet = GetWorld()->SpawnActor<AMagnetTile>( newPos , rotation.Rotator() );
	subMagnet->SetDepth( currentDepth + 1 );
	subMagnet->attractionSpeed = attractionSpeed;
	subMagnet->verticalForceMultiplier = verticalForceMultiplier;
	subMagnet->activate();
}

예제 #6

파일: AnimSequenceBase.cpp 프로젝트: kidaa/UnrealEngineVR

FTransform FTransformCurve::Evaluate(float CurrentTime, float BlendWeight) const
{
	FTransform Value;
	Value.SetTranslation(TranslationCurve.Evaluate(CurrentTime, BlendWeight));
	if (ScaleCurve.DoesContainKey())
	{
		Value.SetScale3D(ScaleCurve.Evaluate(CurrentTime, BlendWeight));
	}
	else
	{
		Value.SetScale3D(FVector(1.f));
	}

	// blend rotation float curve
	FVector RotationAsVector = RotationCurve.Evaluate(CurrentTime, BlendWeight);
	// pitch, yaw, roll order - please check AddKey function
	FRotator Rotator(RotationAsVector.Y, RotationAsVector.Z, RotationAsVector.X);
	Value.SetRotation(FQuat(Rotator));

	return Value;
}

예제 #7

파일: AnimNode_KinectV2Retarget.cpp 프로젝트: ghatighorias/KinectDemoRoom

void FAnimNode_KinectV2Retarget::EvaluateBoneTransforms(USkeletalMeshComponent* SkelComp, FCSPose<FCompactPose>& MeshBases, TArray<FBoneTransform>& OutBoneTransforms)
{


	
	uint8 i = 0;

	if (!KinectBody.bIsTracked)
	{
		return;
	}

	const FBoneContainer BoneContainer = MeshBases.GetPose().GetBoneContainer();

	FA2CSPose TempPose;

	TempPose.AllocateLocalPoses(BoneContainer, SkelComp->LocalAtoms);


	for (auto Bone : KinectBody.KinectBones)
	{


		
		if (BonesToRetarget[i].IsValid(BoneContainer))
		{

			auto DeltaTranform = Bone.MirroredJointTransform.GetRelativeTransform(SkelComp->GetBoneTransform(0));


			//AxisMeshes[Bone.JointTypeEnd]->SetRelativeLocation(PosableMesh->GetBoneLocationByName(RetargetBoneNames[Bone.JointTypeEnd], EBoneSpaces::ComponentSpace));

			auto BoneBaseTransform = DeltaTranform*SkelComp->GetBoneTransform(0);



			FRotator PreAdjusmentRotator = BoneBaseTransform.Rotator();

			FRotator PostBoneDirAdjustmentRotator = (BoneAdjustments[Bone.JointTypeEnd].BoneDirAdjustment.Quaternion()*PreAdjusmentRotator.Quaternion()).Rotator();

			FRotator CompSpaceRotator = (PostBoneDirAdjustmentRotator.Quaternion()*BoneAdjustments[Bone.JointTypeEnd].BoneNormalAdjustment.Quaternion()).Rotator();

			FVector Normal, Binormal, Dir;

			UKismetMathLibrary::BreakRotIntoAxes(CompSpaceRotator, Normal, Binormal, Dir);

			Dir *= BoneAdjustments[Bone.JointTypeEnd].bInvertDir ? -1 : 1;

			Normal *= BoneAdjustments[Bone.JointTypeEnd].bInvertNormal ? -1 : 1;


			FVector X, Y, Z;

			switch (BoneAdjustments[Bone.JointTypeEnd].BoneDirAxis)
			{
			case EAxis::X:
				X = Dir;
				break;
			case EAxis::Y:
				Y = Dir;
				break;
			case EAxis::Z:
				Z = Dir;
				break;
			default:
				;
			}

			switch (BoneAdjustments[Bone.JointTypeEnd].BoneBinormalAxis)
			{
			case EAxis::X:
				X = Binormal;
				break;
			case EAxis::Y:
				Y = Binormal;
				break;
			case EAxis::Z:
				Z = Binormal;
				break;
			default:
				;
			}

			switch (BoneAdjustments[Bone.JointTypeEnd].BoneNormalAxis)
			{
			case EAxis::X:
				X = Normal;
				break;
			case EAxis::Y:
				Y = Normal;
				break;
			case EAxis::Z:
				Z = Normal;
				break;
			default:
				;
			}

			FRotator SwiveledRot = UKismetMathLibrary::MakeRotationFromAxes(X, Y, Z);

			SwiveledRot = (SkelComp->GetBoneTransform(0).Rotator().Quaternion()*SwiveledRot.Quaternion()).Rotator();
			//PosableMesh->SetBoneRotationByName(RetargetBoneNames[Bone.JointTypeEnd], (PosableMesh->GetBoneTransform(0).Rotator().Quaternion()*SwiveledRot.Quaternion()).Rotator(), EBoneSpaces::ComponentSpace);

#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
			if (BoneAdjustments[i].bDebugDraw)
			{
				DrawDebugCoordinateSystem(SkelComp->GetWorld(), SkelComp->GetBoneLocation(BonesToRetarget[i].BoneName), SwiveledRot, 100.f, false, 0.1f);
			}
#endif

			

			FCompactPoseBoneIndex CompactPoseBoneToModify = BonesToRetarget[i].GetCompactPoseIndex(BoneContainer);
			FTransform NewBoneTM = MeshBases.GetComponentSpaceTransform(CompactPoseBoneToModify);

			FAnimationRuntime::ConvertCSTransformToBoneSpace(SkelComp, MeshBases, NewBoneTM, CompactPoseBoneToModify, BCS_ComponentSpace);

			const FQuat BoneQuat(SwiveledRot);

			NewBoneTM.SetRotation(BoneQuat);

			// Convert back to Component Space.
			FAnimationRuntime::ConvertBoneSpaceTransformToCS(SkelComp, MeshBases, NewBoneTM, CompactPoseBoneToModify, BCS_ComponentSpace);


			FAnimationRuntime::SetSpaceTransform(TempPose, BonesToRetarget[i].BoneIndex, NewBoneTM);

			OutBoneTransforms.Add(FBoneTransform(BonesToRetarget[i].GetCompactPoseIndex(BoneContainer), NewBoneTM));
		}

		++i;



		

	}


}

예제 #8

파일: Actor.cpp 프로젝트: RuWhyNot/stealthgame

void Actor::setRotation(const Rotator& rotation)
{
	this->direction = Rotator(rotation);
	this->updateCollision();
	this->onUpdateRotation();
}