自学教程：C++ FRotator函数代码示例

void AMyProjectBlockGrid::BeginPlay(){	Super::BeginPlay();	// Number of blocks	const int32 NumBlocks = Size * Size;	// Loop to spawn each block	for(int32 BlockIndex=0; BlockIndex<NumBlocks; BlockIndex++)	{		const float XOffset = (BlockIndex/Size) * BlockSpacing; // Divide by dimension		const float YOffset = (BlockIndex%Size) * BlockSpacing; // Modulo gives remainder		// Make postion vector, offset from Grid location		const FVector BlockLocation = FVector(XOffset, YOffset, 0.f) + GetActorLocation();		// Spawn a block		AMyProjectBlock* NewBlock = GetWorld()->SpawnActor<AMyProjectBlock>(BlockLocation, FRotator(0,0,0));		// Tell the block about its owner		if(NewBlock != NULL)		{			NewBlock->OwningGrid = this;		}	}}

void FSimpleHMD::SetupView(FSceneViewFamily& InViewFamily, FSceneView& InView){	InView.BaseHmdOrientation = FQuat(FRotator(0.0f,0.0f,0.0f));	InView.BaseHmdLocation = FVector(0.f);//	WorldToMetersScale = InView.WorldToMetersScale;	InViewFamily.bUseSeparateRenderTarget = false;}

FRotator UKismetMathLibrary::ComposeRotators(FRotator A, FRotator B){	FQuat AQuat = FQuat(A);	FQuat BQuat = FQuat(B);	return FRotator(BQuat*AQuat);}

// Called every framevoid APilotPawn::Tick(float DeltaTime){	Super::Tick(DeltaTime);	//InputComponent->GetAxisValue("HandX");	Hand_move_dirvec.X = 3;	if (InputComponent)	{		//InputComponent->GetAxisValue("HandX");		Hand_move_dirvec.X = InputComponent->GetAxisValue("HandX");		Hand_move_dirvec.Y = InputComponent->GetAxisValue("HandY");		Hand_move_dirvec.Z = InputComponent->GetAxisValue("HandZ");		InputComponent->GetAxisValue("RightGrasp") > 0 ? RightHand->MakeGrabAvailable() : RightHand->MakeGrabUnable();		InputComponent->GetAxisValue("LeftGrasp") > 0 ? LeftHand->MakeGrabAvailable() : LeftHand->MakeGrabUnable();		InputComponent->GetAxisValue("LeftSecondaryGrasp") > 0 ? LeftHand->MakeSecondaryGraspAvailable() : LeftHand->MakeSecondaryGraspUnable();		InputComponent->GetAxisValue("RightSecondaryGrasp") > 0 ? RightHand->MakeSecondaryGraspAvailable() : RightHand->MakeSecondaryGraspUnable();	}	else		Hand_move_dirvec.X = 30000;	//Hand_move_dirvec /= (float)Hand_move_dirvec.Size();	RightArm->SetRelativeLocation(FirstPersonCameraComponent->RelativeLocation + RelativeArmposition);	LeftArm->SetRelativeLocation(FirstPersonCameraComponent->RelativeLocation + RelativeArmposition);	LeftRealHandScene->AddLocalOffset(FVector(InputComponent->GetAxisValue("LeftHandX"), InputComponent->GetAxisValue("LeftHandY"), InputComponent->GetAxisValue("LeftHandZ")));	RightRealHandScene->AddLocalOffset(Hand_move_dirvec * 1);	FirstPersonCameraComponent->AddRelativeRotation(FRotator(-InputComponent->GetAxisValue("YaxisLook"), InputComponent->GetAxisValue("XaxisLook"), 0));}

void ABrainNormalInteractiveObject::Tick(float deltaTime){	Super::Tick(deltaTime);	if (_canBeRotate)	{		_currentRotation += (_deltaRotation * (deltaTime / _animDuration));		_durationRotation += deltaTime;		if (_durationRotation > _animDuration)		{			_currentRotation = _targetRotation;			_deltaRotation = FRotator(0, 0, 0); // Annulation du deltaRotation		}		SetActorRotation(_currentRotation);	}	if (_canBeTranslate)	{		_currentTranslation += (_deltaTranslation * deltaTime / _animDuration);		_durationTranslation += deltaTime;		if (_durationTranslation > _animDuration)		{			_currentTranslation = _targetTranslation;			_deltaTranslation = FVector(0, 0, 0); // Annulation du deltaSize		}		SetActorLocation(_currentTranslation,true);	}	if (_canBeScale)	{		_currentScale += (_deltaScale * deltaTime / _animDuration);		_durationScale += deltaTime;		if (_durationScale > _animDuration)		{			_currentScale = _targetScale;			_deltaScale = FVector(0,0,0); // Annulation du deltaSize		}		SetActorScale3D(_currentScale);	}	if (_canBeShear)	{		_currentShearFirstAxis += (_deltaShearFirstAxis * deltaTime / _animDuration);		_currentShearSecondAxis += (_deltaShearSecondAxis * deltaTime / _animDuration);		_durationShear += deltaTime;		if (_durationShear > _animDuration)		{			_currentShearFirstAxis = _targetShearFirstAxis;			_currentShearSecondAxis = _targetShearSecondAxis;			_deltaShearFirstAxis = 0;			_deltaShearSecondAxis = 0;		}		FTransform sTrans = FTransform(Shear(_currentShearFirstAxis, _currentShearSecondAxis));		SetActorTransform(sTrans*_cachedTransform);	}}

// Called every framevoid AGem::Tick( float DeltaTime ){	Super::Tick( DeltaTime );	CollectionParticles->SetColorParameter("ParticleColor", GemColor);	CollectionParticles->SetRelativeLocation(FVector::ZeroVector);	CollectionParticles->SetWorldRotation(FRotator::ZeroRotator);	CollectionParticles->SetWorldScale3D(FVector(1.0f, 1.0f, 1.0f));	//CollectionParticles->UpdateInstances();	FVector loc = GetActorLocation();	loc = FVector(0.0f, 0.0f, 10.0f*DeltaTime*FMath::Cos(curTime*PI));	if (Player != nullptr) {		CollectionParticles->SetVectorParameter("PlayerPosition", 1.0f*(Player->GetActorLocation()-GetActorLocation()));		CollectionParticles->SetVectorParameter("PlayerSize1", Player->GetActorLocation() + (DeltaTime / 0.016f)*FVector(-45.0f, -45.0f, -45.0f));		CollectionParticles->SetVectorParameter("PlayerSize2", Player->GetActorLocation() + (DeltaTime / 0.016f)*FVector(45.0f, 45.0f, 45.0f));		CollectionParticles->SetFloatParameter("Strength", (1.0f/DeltaTime)*FMath::Clamp(GetWorldTimerManager().GetTimerElapsed(PostCollectionTimer) / 2.0f, 0.0f, 1.0f)*FMath::Clamp(GetWorldTimerManager().GetTimerElapsed(PostCollectionTimer) / 2.0f, 0.0f, 1.0f));	} else {		SetActorLocation(GetActorLocation() + loc);		GemModel->AddWorldRotation(FRotator(0.0f, 60.0f*DeltaTime, 0.0f));	}	// Eliot made me put this here.	if (GetWorldTimerManager().GetTimerElapsed(PostCollectionTimer) != -1.0f) {		gemmat->SetScalarParameterValue("Break", 20.0f*GetWorldTimerManager().GetTimerElapsed(PostCollectionTimer));	}	curTime += DeltaTime;}

ARTJamCharacter::ARTJamCharacter(){	// Set size for collision capsule	GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);	GetCapsuleComponent()->OnComponentHit.AddDynamic(this, &ARTJamCharacter::OnHit);	// Don't rotate when the controller rotates.	bUseControllerRotationPitch = false;	bUseControllerRotationYaw = false;	bUseControllerRotationRoll = false;	// Configure character movement	GetCharacterMovement()->bOrientRotationToMovement = true; // Face in the direction we are moving..	GetCharacterMovement()->RotationRate = FRotator(0.0f, 720.0f, 0.0f); // ...at this rotation rate	GetCharacterMovement()->GravityScale = 2.f;	GetCharacterMovement()->AirControl = 0.80f;	GetCharacterMovement()->JumpZVelocity = 1000.f;	GetCharacterMovement()->GroundFriction = 3.f;	GetCharacterMovement()->MaxWalkSpeed = 600.f;	GetCharacterMovement()->MaxFlySpeed = 600.f;	// Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character) 	// are set in the derived blueprint asset named MyCharacter (to avoid direct content references in C++)	bIsDead = false;	NormalImpulse = 800.f;	MaxImpulse = 1000.f;	ForceLength.Z = NormalImpulse;}

AShipPawn::AShipPawn(){	PrimaryActorTick.bCanEverTick = true;	static ConstructorHelpers::FObjectFinder<UStaticMesh> SphereMesh(TEXT("/Game/Assets/Ships/DroneShip"));	MeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MeshComponent"));	MeshComponent->SetCollisionProfileName(UCollisionProfile::Pawn_ProfileName);	MeshComponent->SetStaticMesh(SphereMesh.Object);	MeshComponent->SetMobility(EComponentMobility::Movable);	MeshComponent->SetSimulatePhysics(true);	MeshComponent->BodyInstance.bLockZTranslation = true;	MeshComponent->SetEnableGravity(false);	MeshComponent->SetLinearDamping(ShipLinearDamping);	MeshComponent->SetAngularDamping(ShipAngularDamping);	MeshComponent->BodyInstance.bLockXRotation = true;	MeshComponent->BodyInstance.bLockYRotation = true;	RootComponent = MeshComponent;	CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));	CameraBoom->AttachTo(RootComponent);	CameraBoom->bAbsoluteRotation = true;	CameraBoom->TargetArmLength = 20000.f;	CameraBoom->RelativeRotation = FRotator(-80.f, 0.f, 0.f);	CameraBoom->bDoCollisionTest = false;	CameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("CameraComponent"));	CameraComponent->AttachTo(CameraBoom, USpringArmComponent::SocketName);	CameraComponent->bUsePawnControlRotation = false;}

ACapTheBrainCharacter::ACapTheBrainCharacter(const class FObjectInitializer& PCIP)	: Super(PCIP){	buff = 100;	buffTimer = 0;	buffDelay = 2;	score = 0;	firstUpdate = true;	// Set size for collision capsule	GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);	// set our turn rates for input	BaseTurnRate = 45.f;	BaseLookUpRate = 45.f;	// Don't rotate when the controller rotates. Let that just affect the camera.	bUseControllerRotationPitch = false;	bUseControllerRotationYaw = false;	bUseControllerRotationRoll = false;	// Configure character movement	GetCharacterMovement()->bOrientRotationToMovement = true; // Character moves in the direction of input...		GetCharacterMovement()->RotationRate = FRotator(0.0f, 540.0f, 0.0f); // ...at this rotation rate	GetCharacterMovement()->JumpZVelocity = 200.f;	GetCharacterMovement()->AirControl = 0.2f;	// Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character) 	// are set in the derived blueprint asset named MyCharacter (to avoid direct content references in C++) }

//========================================================================void AHexEditorActor::UpdateBarrierPlacing(){	if (m_CurrentBarrier)	{		check(m_InputType == InputMode::Barriers);				Raycast<AHexTileActor>(this,			[&](auto& resultActor, auto& traceResult) 			{				auto& coords = resultActor->GetCoordinates();				auto tilePos = m_Grid.GetPosition(coords);				auto toHit = traceResult.ImpactPoint - tilePos;				auto nId = GetNeighborId(toHit);				auto neighborRelativeCoordinates = T_HexGrid::HorizontalNeighborIndexes[nId];				auto pos = m_Grid.GetPositionBetweenTiles(coords, coords + neighborRelativeCoordinates);				m_CurrentBarrier->SetActorLocation(pos);				m_CurrentBarrier->SetActorRotation(FRotator(0, 60 * -(int)nId, 0));				m_CurrentBarrier->SetOwningTileBeforePlace(resultActor, nId);			},			[&]()			{				m_CurrentBarrier->SetOwningTileBeforePlace(nullptr);			});	}}

// Sets default valuesADog::ADog(){ 	// Set this pawn to call Tick() every frame.  You can turn this off to improve performance if you don't need it.	PrimaryActorTick.bCanEverTick = true;	AutoPossessPlayer = EAutoReceiveInput::Player0;	CollisionSphere =		CreateDefaultSubobject<USphereComponent>(TEXT("CollisionSphere"));	CollisionSphere->SetCollisionObjectType(ECollisionChannel::ECC_Pawn);	//Might want to tweak this in the editor depending on the size of the static mesh	CollisionSphere->InitSphereRadius(10.0f);	CollisionSphere->SetCollisionProfileName(TEXT("Pawn"));	RootComponent = CollisionSphere;	MovementComponent = CreateDefaultSubobject<UFloatingPawnMovement>("MovementComponent");	MovementComponent->SetUpdatedComponent(RootComponent);	StaticMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("StaticMesh"));	StaticMesh->AttachTo(RootComponent);	OtherMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("OtherMesh"));	OtherMesh->AttachTo(RootComponent);	OtherMesh->SetVisibility(false);	Camera = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));	Camera->AttachTo(RootComponent);	Camera->SetRelativeLocation(FVector(-100.0f, 0.0f, 200.0f));	Camera->SetRelativeRotation(FRotator(-60.0f, 0.0f, 0.0f));}

// Sets default valuesAMyPawn::AMyPawn(){	// Set this pawn to call Tick() every frame.  You can turn this off to improve performance if you don't need it.	PrimaryActorTick.bCanEverTick = true;	//Set this pawn to be controlled by the lowest numbered player	AutoPossessPlayer = EAutoReceiveInput::Player0;	//Create a dummy root component to attach things to.	RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("RootComponent"));	//create a camera and a visible object	UCameraComponent* OurCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("OurCamera"));	OurVisibleComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("OurVisibleComponent"));	//attach our camera and visible object to the root	OurCamera->AttachTo(RootComponent);	(*OurVisibleComponent).AttachTo(RootComponent);	//offset camera	OurCamera->SetRelativeLocation(FVector(-250, 0, 250));	//rotate camera	OurCamera->SetRelativeRotation(FRotator(-45, 0, 0));	InitLocation = GetActorLocation();}

FCreatureAnimStoreEditorViewportClient::FCreatureAnimStoreEditorViewportClient(const TWeakPtr<class SEditorViewport>& InEditorViewportWidget /*= nullptr*/, UCreatureAnimationClipsStore* EditingAnimStore)    :FEditorViewportClient(nullptr, &OwnerScene, InEditorViewportWidget)    , EditingStore(EditingAnimStore){    PreviewScene = &OwnerScene;    ((FAssetEditorModeManager*)ModeTools)->SetPreviewScene(PreviewScene);    DrawHelper.bDrawGrid = true;    DrawHelper.bDrawPivot = true;    /*SetViewLocation(FVector(0, 30, 0));    SetLookAtLocation(FVector(0, -30, 0));*/    SetRealtime(true);    //向PreviewScene添加Component    EditingCreatureMesh = NewObject<UCreatureMeshComponent>();    //设置CreatureMesh组件    SetUpEditingCreatureMesh();    PreviewScene->AddComponent(EditingCreatureMesh, FTransform::Identity);    EditingCreatureMesh->SetRelativeRotation(FRotator(0, 90, 0));    //设置Camera    SetUpCamera();    if (EditingStore->ClipList.Num()!=0)    {        //默认播放第一个Clip        EditingCreatureMesh->SetBluePrintActiveCollectionClip_Name(EditingStore->ClipList[0].ClipName);    }}

// Sets default valuesASceneBarricades::ASceneBarricades(){ 	// Set this pawn to call Tick() every frame.  You can turn this off to improve performance if you don't need it.	PrimaryActorTick.bCanEverTick = true;   struct FConstructorStatics   {      ConstructorHelpers::FObjectFinderOptional<UStaticMesh> barricadeShape;      ConstructorHelpers::FObjectFinderOptional<UMaterialInstance> barricadeMaterial;      FConstructorStatics()         : barricadeShape(TEXT("/Game/MapProps/blockade.blockade"))         , barricadeMaterial(TEXT("Material'/Game/MapProps/cementLight.cementLight'"))      {      }   };   static FConstructorStatics ConstructorStatics;   // Create dummy root scene component   //DummyRoot = CreateDefaultSubobject<USceneComponent>(TEXT("Dummy0"));   //RootComponent = DummyRoot;   ItemBasicMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("item_shape"));   // Create random mesh component   ItemBasicMesh->SetStaticMesh(ConstructorStatics.barricadeShape.Get());   ItemBasicMesh->SetMaterial(0, ConstructorStatics.barricadeMaterial.Get());   ItemBasicMesh->SetRelativeScale3D(FVector(0.2f,0.2f,0.2f));   ItemBasicMesh->SetRelativeLocation(FVector(0.f,0.f,0.f));   ItemBasicMesh->SetRelativeRotation(FRotator(0.f, 0.f, 0.f));   //ItemBasicMesh->AttachTo(DummyRoot);   health = 3;   this->OnActorHit.AddDynamic(this, &ASceneBarricades::onHit);}

FRotator CombineRotators(FRotator A, FRotator B){    FQuat AQuat = FQuat(A);    FQuat BQuat = FQuat(B);    return FRotator(BQuat*AQuat);}

void UTankTurret::Rotate(float RelativeSpeed){	RelativeSpeed = FMath::Clamp<float>(RelativeSpeed, -1, +1);	auto RotationChange = RelativeSpeed * MaxDegreesPerSecond * GetWorld()->DeltaTimeSeconds;	auto Rotation = RelativeRotation.Yaw + RotationChange;	SetRelativeRotation(FRotator(0, Rotation, 0));}

//Conversion - use find and replace to change behavior, no scaling version is typically used for orientationsFVector convertLeapToUE(Leap::Vector leapVector){    //Convert Axis    FVector vect = FVector(-leapVector.z, leapVector.x, leapVector.y);    //Hmd orientation adjustment    if (LeapShouldAdjustForFacing)    {        FRotator rotation = FRotator(90.f, 0.f, 180.f);        vect = FQuat(rotation).RotateVector(vect);        if (LeapShouldAdjustRotationForHMD)        {            if (GEngine->HMDDevice.IsValid())            {                FQuat orientationQuat;                FVector position;                GEngine->HMDDevice->GetCurrentOrientationAndPosition(orientationQuat, position);                vect = orientationQuat.RotateVector(vect);            }        }    }    return vect;}

// Sets default valuesAPawnWithCamera::APawnWithCamera(){ 	// Set this pawn to call Tick() every frame.  You can turn this off to improve performance if you don't need it.	PrimaryActorTick.bCanEverTick = true;		//Create this actors components	RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("RootComponent"));	OurCameraSpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraSpringArm"));	OurCameraSpringArm->AttachTo(RootComponent);	OurCameraSpringArm->SetRelativeLocationAndRotation(FVector(0.0f, 0.0f, 50.0f), FRotator(-60.0f, 0.0f, 0.0f));	OurCameraSpringArm->TargetArmLength = 400.f;	OurCameraSpringArm->bEnableCameraLag = true;	OurCameraSpringArm->CameraLagSpeed = 3.0f;	//create and attach the camera	OurCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("GameCamera"));	OurCamera->AttachTo(OurCameraSpringArm, USpringArmComponent::SocketName);	//take control of the default player	AutoPossessPlayer = EAutoReceiveInput::Player0;	//default speed values	ForwardSpeed = 300.0f;	StrafeSpeed = 200.0f;	//default look sensitivity	LookSensitivityX = 2.0f;	LookSensitivityY = 2.0f;}

AMobileAgentSlickPawn::AMobileAgentSlickPawn(){		static ConstructorHelpers::FObjectFinder<UStaticMesh> ShipMesh(TEXT("/Game/TwinStick/Meshes/TwinStickUFO.TwinStickUFO"));	// Create the mesh component	ShipMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ShipMesh"));	RootComponent = ShipMeshComponent;	ShipMeshComponent->SetCollisionProfileName(UCollisionProfile::Pawn_ProfileName);	ShipMeshComponent->SetStaticMesh(ShipMesh.Object);		// Create a camera boom...	CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));	CameraBoom->AttachTo(RootComponent);	CameraBoom->bAbsoluteRotation = true; // Don't want arm to rotate when ship does	CameraBoom->TargetArmLength = 1200.f;	CameraBoom->RelativeRotation = FRotator(-90.f, 0.f, 0.f);	CameraBoom->bDoCollisionTest = false; // Don't want to pull camera in when it collides with level	// Create a camera...	CameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("TopDownCamera"));	CameraComponent->AttachTo(CameraBoom, USpringArmComponent::SocketName);	CameraComponent->bUsePawnControlRotation = false;	// Camera does not rotate relative to arm	// Movement	MoveSpeed = 1000.0f;}

void AMech_RPGCharacter::Tick(float DeltaTime) {	Super::Tick(DeltaTime);	if (!isDead) {		GetCharacterMovement()->MaxWalkSpeed = speed * speedModifier;		if (GetHealth() < GetMaxHealth()) {			float regen = !inCombat ? GetMaxHealth() * 0.15 : healthRegen;			health += regen * DeltaTime;			GetFloatingStats()->UpdateHealthBar();			if (GetCharacterStats() != nullptr) {				GetCharacterStats()->UpdateHealthBar();			}		}		if (stats->GetUserWidgetObject() != nullptr && stats->GetUserWidgetObject() != nullptr) {			if (mIsChildOf(GetController(), AMech_RPGPlayerController::StaticClass()) && GetTopDownCamera() != nullptr) {				UMiscLibrary::SetCameraRot(FRotator(-GetTopDownCamera()->GetComponentRotation().Pitch, UMiscLibrary::GetWidgetYaw(GetTopDownCamera()) + 90, 0));				GetStats()->SetWorldRotation(UMiscLibrary::GetCameraRot());			}			else if (GetStats() != nullptr) {				GetStats()->SetWorldRotation(UMiscLibrary::GetCameraRot());			}		}	}	CLAMP(health, GetMaxHealth(), 0);}

void FCameraManager::addRotationToViewportCamera(FRotator deltaRot){	if (_viewportCamera)	{		_viewportCameraRotation += deltaRot;		Vector3 aux = _viewportCameraRotation.toEuler();		//Clamp pitch Pitch		aux.x = Math::clamp(aux.x, _pitchRotationLimitMin, _pitchRotationLimitMax);		//Set back yaw to 0 if it exceeds 360		if (aux.y > 359.9f || aux.y < -359.9f)		{			aux.y = 0;		}		_viewportCameraRotation = FRotator(aux);		_viewportCamera->setLocalRotation(_viewportCameraRotation.toQuaternion());	}	else	{		FLog(FLog::FAILURE, "There is no Viewport Camera set");		assert(0);	}}

// Sets default valuesAPawnWithCamera::APawnWithCamera(){        //To create "Voyager" and for it to have collision, we must make a camera inside of a sphere    //This way we can zip about the universe and not collide with planets/the sun    PrimaryActorTick.bCanEverTick = true;        // Our root component will be a sphere that reacts to physics    USphereComponent* SphereComponent = CreateDefaultSubobject<USphereComponent>(TEXT("RootComponent"));    RootComponent = SphereComponent;    SphereComponent->InitSphereRadius(100.0f);    SphereComponent->SetCollisionProfileName(TEXT("Pawn"));        OurCameraSpringArm=CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraSpringArm"));    OurCameraSpringArm->AttachTo(RootComponent);    OurCameraSpringArm->RelativeRotation = FRotator(-10.0f, 0.0f, 0.0f);    OurCameraSpringArm->TargetArmLength = 0.0f;    OurCameraSpringArm->bEnableCameraLag = false;    OurCameraSpringArm->CameraLagSpeed = 0.0f;            //Create camera and attach spring arm    OurCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("GameCamera"));    OurCamera->AttachTo(OurCameraSpringArm, USpringArmComponent::SocketName);        // Create an instance of our movement component, and tell it to update our root component.    OurMovementComponent = CreateDefaultSubobject<UVoyagerPawnMovementComponent>(TEXT("CustomMovementComponent"));    OurMovementComponent->UpdatedComponent = RootComponent;        //Take control of the default Player    AutoPossessPlayer = EAutoReceiveInput::Player0;        //Set bearing mode time to 2 (default) it is editable from the editor    BearingTime = 2.0f;    SphereVisualLocation = (FVector(0.0f, 0.0f, -40.0f));}

void AActor::EditorApplyRotation(const FRotator& DeltaRotation, bool bAltDown, bool bShiftDown, bool bCtrlDown){	if( RootComponent != NULL )	{		const FRotator Rot = RootComponent->GetAttachParent() != NULL ? GetActorRotation() : RootComponent->RelativeRotation;		FRotator ActorRotWind, ActorRotRem;		Rot.GetWindingAndRemainder(ActorRotWind, ActorRotRem);		const FQuat ActorQ = ActorRotRem.Quaternion();		const FQuat DeltaQ = DeltaRotation.Quaternion();		const FQuat ResultQ = DeltaQ * ActorQ;		const FRotator NewActorRotRem = FRotator( ResultQ );		FRotator DeltaRot = NewActorRotRem - ActorRotRem;		DeltaRot.Normalize();		if( RootComponent->GetAttachParent() != NULL )		{			RootComponent->SetWorldRotation( Rot + DeltaRot );		}		else		{			// No attachment.  Directly set relative rotation (to support winding)			RootComponent->SetRelativeRotation( Rot + DeltaRot );		}	}	else	{		UE_LOG(LogActor, Warning, TEXT("WARNING: EditorApplyRotation %s has no root component"), *GetName() );	}}

// Called every framevoid AEquipmentPickup::Tick( float DeltaTime ){	Super::Tick( DeltaTime );	t += DeltaTime;	SetActorRelativeLocation(start + FMath::Sin(t*PI)*25.0f*FVector::UpVector);	AddActorWorldRotation(FRotator(0.0f, DeltaTime*135.0f, 0.0f));}

FRotator AGGJ16_Player::CalculateTargetRotation(){	float Yaw = FMath::RadiansToDegrees(FMath::Atan2(CurrentInputRotation.Y, CurrentInputRotation.X));	SetActorRotation(FMath::Lerp(GetActorRotation(), FRotator(0.f, Yaw, 0.f), RotationAlpha));	return GetActorRotation();}

AsbrProjectile::AsbrProjectile(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer){	CollisionComponent = ObjectInitializer.CreateDefaultSubobject<USphereComponent>(this, TEXT("SphereComponent"));	CollisionComponent->InitSphereRadius(0.5f);	RootComponent = CollisionComponent;	Mesh = ObjectInitializer.CreateDefaultSubobject<UStaticMeshComponent>(this, TEXT("Mesh"));	Mesh->SetRelativeRotation(FRotator(0, 0, 0), false);	Mesh->AttachTo(RootComponent);	AudioComponent = ObjectInitializer.CreateDefaultSubobject<UAudioComponent>(this, TEXT("AudioComponent"));	AudioComponent->bAutoActivate = false;	AudioComponent->bAutoDestroy = false;	AudioComponent->AttachParent = RootComponent;	ExplosionPCS = ObjectInitializer.CreateDefaultSubobject<UParticleSystemComponent>(this, TEXT("ExplosionPCS"));	ExplosionPCS->bAutoActivate = false;	ExplosionPCS->bAutoDestroy = false;	ExplosionPCS->AttachParent = RootComponent;	ProjectileMovement = ObjectInitializer.CreateDefaultSubobject<UProjectileMovementComponent>(this, TEXT("ProjectileComponent"));	ProjectileMovement->UpdatedComponent = CollisionComponent;	//ProjectileMovement->OnProjectileStop.AddDynamic(this, &AsbrProjectile::OnImpact);	ProjectileMovement->OnProjectileStop.AddDynamic(this, &AsbrProjectile::OnImpact);	ProjectileMovement->InitialSpeed = 3000.f;	ProjectileMovement->MaxSpeed = 3000.f;	ProjectileMovement->bRotationFollowsVelocity = true;	ProjectileMovement->bShouldBounce = true;	ProjectileMovement->Bounciness = 0.3f;}

void UTangoARCamera::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction){	if (UTangoDevice::Get().GetCurrentConfig().AreaDescription.UUID.Len() > 0)	{		FrameOfReference = FTangoCoordinateFramePair(ETangoCoordinateFrameType::AREA_DESCRIPTION, ETangoCoordinateFrameType::CAMERA_COLOR);	}	else	{		FrameOfReference = FTangoCoordinateFramePair(ETangoCoordinateFrameType::START_OF_SERVICE, ETangoCoordinateFrameType::CAMERA_COLOR);	}	if (ARScreen == nullptr && TangoARHelpers::DataIsReady())	{		ARScreen = NewObject<UTangoARScreenComponent>(this, TEXT("TangoCameraARScreen"));		if (ARScreen)		{			ARScreen->RegisterComponent();            ARScreen->AttachToComponent(this, FAttachmentTransformRules::KeepWorldTransform, NAME_None);			FVector2D LowerLeft, UpperRight, NearFar;			TangoARHelpers::GetNearPlane(LowerLeft, UpperRight, NearFar);			FVector2D UVShift = TangoARHelpers::GetARUVShift();			NearFar.Y *= 0.99f;			FVector LL = FVector(NearFar.Y, LowerLeft.X*(NearFar.Y / NearFar.X), LowerLeft.Y*(NearFar.Y / NearFar.X));			FVector UR = FVector(NearFar.Y, UpperRight.X*(NearFar.Y / NearFar.X), UpperRight.Y*(NearFar.Y / NearFar.X));			ARScreen->SetRelativeLocation((LL + UR)*0.5f);			ARScreen->SetRelativeRotation(FQuat::Identity);			ARScreen->SetRelativeScale3D(FVector(1, FMath::Abs(UR.Y - LL.Y) / (100.0f*(1.0f - 2.0f*UVShift.X)), FMath::Abs(LL.Z - UR.Z) / (100.0f*(1.0f - 2.0f*UVShift.Y))));		}		else		{			UE_LOG(ProjectTangoPlugin, Error, TEXT("UTangoARCamera::TickComponent: Could not instantiate TangoARScreen for TangoARCamera. There will be no camera passthrough."));		}	}	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);	if (UTangoDevice::Get().getTangoDeviceMotionPointer())	{		FTangoPoseData LatestPose = UTangoDevice::Get().getTangoDeviceMotionPointer()->GetPoseAtTime(FrameOfReference, 0);		//Only move the component if the pose status is valid.		if (LatestPose.StatusCode == ETangoPoseStatus::VALID)		{			SetRelativeLocation(LatestPose.Position);			SetRelativeRotation(FRotator(LatestPose.QuatRotation));		}	}	else	{		UE_LOG(ProjectTangoPlugin, Warning, TEXT("UTangoARCamera::TickComponent: Could not update transfrom because Tango Service is not connect or has motion tracking disabled!"));	}	if (!ViewExtension.IsValid() && GEngine)	{		TSharedPtr< FTangoViewExtension, ESPMode::ThreadSafe > NewViewExtension(new FTangoViewExtension(Cast<ITangoARInterface>(this)));		ViewExtension = NewViewExtension;		GEngine->ViewExtensions.Add(ViewExtension);	}}

void AMMO_Character::ShootArrow(){	if(Role<ROLE_Authority)	ArrowsLeft--;	FActorSpawnParameters spawnParams;	spawnParams.Owner = this;	spawnParams.Instigator = Instigator;	FVector SpawnLoc = FVector(0);	FVector DirHelper = FVector(0);	if (LockedTarget)	{		SpawnLoc = Player_SkeletalMeshComponent->GetComponentLocation();		DirHelper = LockedTarget->GetActorLocation() - SpawnLoc;	}	else	{		SpawnLoc = ShootingLocation->GetComponentLocation();		DirHelper = LastKnownLocationOfTarget - SpawnLoc;	}		FRotator SpawnRot = Player_SpringArmComponent->GetComponentRotation() + FRotator(0,-90,0);	if(Role == ROLE_Authority)	FinalArrowDamage = BaseAttack + FMath::RandRange(AttackBonusMin, AttackBonusMax);	AArcherArrow* OurNewObject = GetWorld()->SpawnActor<AArcherArrow>(MyArrowObject, SpawnLoc , SpawnRot, spawnParams);		OurNewObject->ApplyForce(ArrowForce, this, DirHelper.GetSafeNormal());}

ATrainingDayCharacter::ATrainingDayCharacter(){	// Set size for collision capsule	GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);	// set our turn rates for input	BaseTurnRate = 45.f;	BaseLookUpRate = 45.f;	// Don't rotate when the controller rotates. Let that just affect the camera.	bUseControllerRotationPitch = false;	bUseControllerRotationYaw = false;	bUseControllerRotationRoll = false;	// Configure character movement	GetCharacterMovement()->bOrientRotationToMovement = true; // Character moves in the direction of input...		GetCharacterMovement()->RotationRate = FRotator(0.0f, 540.0f, 0.0f); // ...at this rotation rate	GetCharacterMovement()->JumpZVelocity = 600.f;	GetCharacterMovement()->AirControl = 0.2f;	// Create a camera boom (pulls in towards the player if there is a collision)	CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));	CameraBoom->AttachTo(RootComponent);	CameraBoom->TargetArmLength = 300.0f; // The camera follows at this distance behind the character		CameraBoom->bUsePawnControlRotation = true; // Rotate the arm based on the controller	// Create a follow camera	FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));	FollowCamera->AttachTo(CameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation	FollowCamera->bUsePawnControlRotation = false; // Camera does not rotate relative to arm	// Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character) 	// are set in the derived blueprint asset named MyCharacter (to avoid direct content references in C++)}

AMutagenPlayer::AMutagenPlayer(const FObjectInitializer& ObjectInitializer)	: Super(ObjectInitializer){	// Set size for collision capsule	GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);	// set our turn rates for input	BaseTurnRate = 45.f;	BaseLookUpRate = 45.f;	// Don't rotate when the controller rotates. Let that just affect the camera.	bUseControllerRotationPitch = false;	bUseControllerRotationYaw = false;	bUseControllerRotationRoll = false;	// Configure character movement	GetCharacterMovement()->bOrientRotationToMovement = true; // Character moves in the direction of input...		GetCharacterMovement()->RotationRate = FRotator(0.0f, 540.0f, 0.0f); // ...at this rotation rate	GetCharacterMovement()->JumpZVelocity = 600.f;	GetCharacterMovement()->AirControl = 0.2f;	// Create a camera boom (pulls in towards the player if there is a collision)	cameraBoom = ObjectInitializer.CreateDefaultSubobject<USpringArmComponent>(this, TEXT("CameraBoom"));	cameraBoom->AttachTo(RootComponent);	cameraBoom->TargetArmLength = 300.0f; // The camera follows at this distance behind the character		cameraBoom->bUsePawnControlRotation = true; // Rotate the arm based on the controller	// Create a follow camera	followCamera = ObjectInitializer.CreateDefaultSubobject<UCameraComponent>(this, TEXT("FollowCamera"));	followCamera->AttachTo(cameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation	followCamera->bUsePawnControlRotation = false; // Camera does not rotate relative to arm}