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;
}
void AClashOfBallsBall::AddMovement_Implementation(bool ForwardBackward, float Value, FRotator Rotation)
{
if (ForwardBackward)
{
const FVector Torque = Rotation.RotateVector(FVector(0, Value * RollTorque, 0.f));
Ball->AddTorque(Torque);
}
else
{
const FVector Torque = Rotation.RotateVector(FVector(-1 * Value * RollTorque, 0.f, 0.f));
Ball->AddTorque(Torque);
}
}
void AMobileOpenCVCharacter::OnFire()
{
// try and fire a projectile
if (ProjectileClass != NULL)
{
const FRotator SpawnRotation = GetControlRotation();
// MuzzleOffset is in camera space, so transform it to world space before offsetting from the character location to find the final muzzle position
const FVector SpawnLocation = GetActorLocation() + SpawnRotation.RotateVector(GunOffset);
UWorld* const World = GetWorld();
if (World != NULL)
{
// spawn the projectile at the muzzle
World->SpawnActor<AMobileOpenCVProjectile>(ProjectileClass, SpawnLocation, SpawnRotation);
}
}
// try and play the sound if specified
if (FireSound != NULL)
{
UGameplayStatics::PlaySoundAtLocation(this, FireSound, GetActorLocation());
}
// try and play a firing animation if specified
if(FireAnimation != NULL)
{
// Get the animation object for the arms mesh
UAnimInstance* AnimInstance = Mesh1P->GetAnimInstance();
if(AnimInstance != NULL)
{
AnimInstance->Montage_Play(FireAnimation, 1.f);
}
}
}
void ATP_TwinStickPawn::FireShot(FVector FireDirection)
{
// If we it's ok to fire again
if (bCanFire == true)
{
// If we are pressing fire stick in a direction
if (FireDirection.SizeSquared() > 0.0f)
{
const FRotator FireRotation = FireDirection.Rotation();
// Spawn projectile at an offset from this pawn
const FVector SpawnLocation = GetActorLocation() + FireRotation.RotateVector(GunOffset);
UWorld* const World = GetWorld();
if (World != NULL)
{
// spawn the projectile
World->SpawnActor<ATP_TwinStickProjectile>(SpawnLocation, FireRotation);
}
bCanFire = false;
World->GetTimerManager().SetTimer(TimerHandle_ShotTimerExpired, this, &ATP_TwinStickPawn::ShotTimerExpired, FireRate);
// try and play the sound if specified
if (FireSound != nullptr)
{
UGameplayStatics::PlaySoundAtLocation(this, FireSound, GetActorLocation());
}
bCanFire = false;
}
}
}
void AITP380_RocketThingPawn::FireCluster(){
UWorld* const World = GetWorld();
for (int k = 0; k < NumFiredAtOnce; k++){
FRotator FireRotation = curFireDirection.Rotation();
FRotator randRotation = FRotator(FireRotation.Pitch, FireRotation.Yaw + FMath::RandRange(-90, 90), FireRotation.Roll);
// Spawn projectile at an offset from this pawn
const FVector SpawnLocation = GetActorLocation() + randRotation.RotateVector(GunOffset);
if (World != NULL)
{
// spawn the projectile
ARocketProjectile* projectile = World->SpawnActor<ARocketProjectile>(SpawnLocation, randRotation);
projectile->targetDirection = FireRotation.Vector();
}
//bCanFire = false;
// try and play the sound if specified
}
World->GetTimerManager().SetTimer(TimerHandle_ShotTimerExpired, this, &AITP380_RocketThingPawn::ShotTimerExpired, FireRate);
projectilesFired += NumFiredAtOnce;
if (projectilesFired < NumFiredTotal)
World->GetTimerManager().SetTimer(TimerHandle_ShotIntervalExpired, this, &AITP380_RocketThingPawn::FireCluster, pauseBetweenFires);
else
projectilesFired = 0;
}
void APlayerCharacter::SpawnKeeper()
{
if (Role < ROLE_Authority)
{
return;
}
// try and fire a projectile
if (KeeperClass)
{
FournoidUtils::BlueMessage(TEXT("Spwaning Keeper"));
// Get the actors rotation caused by control in world space.
const FRotator SpawnRotation = GetControlRotation();
// Tarnsform the SpawnOffset from local space to world space.
const FVector SpawnLocation = GetActorLocation() + SpawnRotation.RotateVector(SpawnOffset);
UWorld* const World = GetWorld();
if (World)
{
FournoidUtils::BlueMessage(TEXT("Spwaning..."));
// spawn the projectile at the muzzle
auto SpawnedKeeper = World->SpawnActor<AFournoidKeeper>(KeeperClass, SpawnLocation, SpawnRotation);
SpawnedKeeper->SetKeeperMaster(this);
}
}
}
FVector UInterpToMovementComponent::ComputeMoveDelta(float InTime) const
{
FVector MoveDelta = FVector::ZeroVector;
FVector NewPosition = FVector::ZeroVector;
//Find current control point
float Time = 0.0f;
int32 CurrentControlPoint = INDEX_NONE;
// Always use the end point if we are at the end
if (InTime >= 1.0f)
{
CurrentControlPoint = ControlPoints.Num() - 1;
}
else
{
for (int32 iSpline = 0; iSpline < ControlPoints.Num(); iSpline++)
{
float NextTime = Time + ControlPoints[iSpline].Percentage;
if (InTime < NextTime)
{
CurrentControlPoint = iSpline;
break;
}
Time = NextTime;
}
}
// If we found a valid control point get the position between it and the next
if (CurrentControlPoint != INDEX_NONE)
{
FRotator CurrentRotation = UpdatedComponent->GetComponentRotation();
float Base = InTime - ControlPoints[CurrentControlPoint].StartTime;
float ThisAlpha = Base / ControlPoints[CurrentControlPoint].Percentage;
FVector BeginControlPoint = ControlPoints[CurrentControlPoint].PositionControlPoint;
BeginControlPoint = CurrentRotation.RotateVector(BeginControlPoint) + ( ControlPoints[CurrentControlPoint].bPositionIsRelative == true ? StartLocation : FVector::ZeroVector);
int32 NextControlPoint = FMath::Clamp(CurrentControlPoint + 1, 0, ControlPoints.Num() - 1);
FVector EndControlPoint = ControlPoints[NextControlPoint].PositionControlPoint;
EndControlPoint = CurrentRotation.RotateVector(EndControlPoint) + ( ControlPoints[NextControlPoint].bPositionIsRelative == true ? StartLocation : FVector::ZeroVector);
NewPosition = FMath::Lerp(BeginControlPoint, EndControlPoint, ThisAlpha);
}
FVector CurrentPosition = UpdatedComponent->GetComponentLocation();
MoveDelta = NewPosition - CurrentPosition;
return MoveDelta;
}
void UAnimBone::ChangeBasis(FRotator PreBase, FRotator PostBase, bool AdjustVectors)
{
//Adjust the orientation
FRotator PostCombine = CombineRotators(Orientation, PostBase);
Orientation = CombineRotators(PreBase, PostCombine);
//Rotate our vector/s
if (AdjustVectors)
{
Position = PostBase.RotateVector(Position);
}
}
void AHair::SetNodeRotation(AHairNode* Node, FRotator Rotation, bool IsPropToChildren)
{
AHairSegment* Segment = Node->Segment;
USplineComponent* Spline = Segment->Spline;
FVector Up = Spline->GetUpVectorAtSplinePoint(Node->Index, ESplineCoordinateSpace::World);
FVector UpRotated = Rotation.RotateVector(Up);
Spline->SetUpVectorAtSplinePoint(Node->Index, UpRotated, ESplineCoordinateSpace::World);
Node->SetActorRotation(Spline->GetRotationAtSplinePoint(Node->Index, ESplineCoordinateSpace::World));
UpdateSegment(Segment);
}
void USCarryObjectComponent::RotateActorAroundPoint(AActor* RotateActor, FVector RotationPoint, FRotator AddRotation)
{
FVector Loc = RotateActor->GetActorLocation() - RotationPoint;
FVector RotatedLoc = AddRotation.RotateVector(Loc);
FVector NewLoc = RotationPoint + RotatedLoc;
/* Compose the rotators, use Quats to avoid gimbal lock */
FQuat AQuat = FQuat(RotateActor->GetActorRotation());
FQuat BQuat = FQuat(AddRotation);
FRotator NewRot = FRotator(BQuat*AQuat);
RotateActor->SetActorLocationAndRotation(NewLoc, NewRot);
}
void AHunterMarxo::ThrowSmokeGrenade()
{
if (!bSmokeGrenadeIsOnCD && SmokeGrenade != NULL)
{
SmokeGrenade->GetDefaultObject<ABasicProjectile>()->SetDamage(0.f);
const FRotator SpawnRotation = CameraArm->GetComponentRotation();
const FVector SpawnLocation = GetActorLocation() + SpawnRotation.RotateVector(SmokeGrenadeOffset);
UWorld* const World = GetWorld();
if (World != NULL)
{
World->SpawnActor<ABasicProjectile>(SmokeGrenade, SpawnLocation, SpawnRotation);
}
}
}
void ATotemCharacter::OnFire()
{
//only server can spawn projectile theoretically
// try and fire a projectile
if (ProjectileClass != NULL || FireProjectileClass != NULL)
{
const FRotator SpawnRotation = GetControlRotation();
// MuzzleOffset is in camera space, so transform it to world space before offsetting from the character location to find the final muzzle position
const FVector SpawnLocation = GetActorLocation() + SpawnRotation.RotateVector(GunOffset);
UWorld* const World = GetWorld();
if (World != NULL)
{
//to add owner and instigator information
FActorSpawnParameters SpawnParams;
SpawnParams.Owner = Cast<ATotemPlayerController>(Controller);
SpawnParams.Instigator = Instigator;
//When the server function is called by serve, it also execute.
ServerSpawnProjectile(SpawnLocation, SpawnRotation, SpawnParams.Owner, SpawnParams.Instigator);
// spawn the projectile at the muzzle single player version
//World->SpawnActor<ATotemProjectile>(ProjectileClass, SpawnLocation, SpawnRotation, SpawnParams);
}
}
// try and play the sound if specified
if (FireSound != NULL)
{
UGameplayStatics::PlaySoundAtLocation(this, FireSound, GetActorLocation());
}
// try and play a firing animation if specified
if (FireAnimation != NULL)
{
// Get the animation object for the arms mesh
UAnimInstance* AnimInstance = Mesh1P->GetAnimInstance();
if (AnimInstance != NULL)
{
AnimInstance->Montage_Play(FireAnimation, 1.f);
}
}
}
void AActor::EditorApplyScale( const FVector& DeltaScale, const FVector* PivotLocation, bool bAltDown, bool bShiftDown, bool bCtrlDown )
{
if( RootComponent != NULL )
{
const FVector CurrentScale = GetRootComponent()->RelativeScale3D;
// @todo: Remove this hack once we have decided on the scaling method to use.
FVector ScaleToApply;
if( AActor::bUsePercentageBasedScaling )
{
ScaleToApply = CurrentScale * (FVector(1.0f) + DeltaScale);
}
else
{
ScaleToApply = CurrentScale + DeltaScale;
}
GetRootComponent()->SetRelativeScale3D(ScaleToApply);
if (PivotLocation)
{
const FVector CurrentScaleSafe(CurrentScale.X ? CurrentScale.X : 1.0f,
CurrentScale.Y ? CurrentScale.Y : 1.0f,
CurrentScale.Z ? CurrentScale.Z : 1.0f);
const FRotator ActorRotation = GetActorRotation();
const FVector WorldDelta = GetActorLocation() - (*PivotLocation);
const FVector LocalDelta = (ActorRotation.GetInverse()).RotateVector(WorldDelta);
const FVector LocalScaledDelta = LocalDelta * (ScaleToApply / CurrentScaleSafe);
const FVector WorldScaledDelta = ActorRotation.RotateVector(LocalScaledDelta);
GetRootComponent()->SetWorldLocation(WorldScaledDelta + (*PivotLocation));
}
}
else
{
UE_LOG(LogActor, Warning, TEXT("WARNING: EditorApplyTranslation %s has no root component"), *GetName() );
}
FEditorSupportDelegates::UpdateUI.Broadcast();
}
void AUDKPresentationCharacter::OnFire()
{
if (CharacterMovement->IsMovingOnGround()) {
ammo = maxAmmo;
}
if (ammo <= 0) return;
// try and fire a projectile
if (ProjectileClass != NULL)
{
const FRotator SpawnRotation = GetControlRotation();
// MuzzleOffset is in camera space, so transform it to world space before offsetting from the character location to find the final muzzle position
const FVector SpawnLocation = GetActorLocation() + SpawnRotation.RotateVector(GunOffset);
ammo--;
CharacterMovement->Velocity = GetControlRotation().Vector()*(-1000) + 0.5f * CharacterMovement->Velocity;
UWorld* const World = GetWorld();
if (World != NULL)
{
// spawn the projectile at the muzzle
World->SpawnActor<AUDKPresentationProjectile>(ProjectileClass, SpawnLocation, SpawnRotation);
}
}
// try and play the sound if specified
if (FireSound != NULL)
{
UGameplayStatics::PlaySoundAtLocation(this, FireSound, GetActorLocation());
}
// try and play a firing animation if specified
if(FireAnimation != NULL)
{
// Get the animation object for the arms mesh
UAnimInstance* AnimInstance = Mesh1P->GetAnimInstance();
if(AnimInstance != NULL)
{
AnimInstance->Montage_Play(FireAnimation, 1.f);
}
}
}
void AHunterMarxo::Attack()
{
if (MainProjectile != NULL)
{
if (Ammo < 1)
{
Reload();
return;
}
MainProjectile ->GetDefaultObject<ABasicProjectile>()->SetDamage(Super::Attack);
const FRotator SpawnRotation = CameraArm->GetComponentRotation();
const FVector SpawnLocation = GetActorLocation() + SpawnRotation.RotateVector(MainOffset);
UWorld* const World = GetWorld();
if (World != NULL)
{
World->SpawnActor<ABasicProjectile>(MainProjectile, SpawnLocation, SpawnRotation);
}
Ammo--;
}
}
void USceneCapturer::SetPositionAndRotation( int32 CurrentHorizontalStep, int32 CurrentVerticalStep, int32 CaptureIndex )
{
FRotator Rotation = StartRotation;
Rotation.Yaw += CurrentHorizontalStep * hAngIncrement;
Rotation.Pitch -= CurrentVerticalStep * vAngIncrement;
Rotation = Rotation.Clamp();
FVector Offset( 0.0f, eyeSeparation / 2.0f, 0.0f );
if (dbgDisableOffsetRotation)
{
//For rendering near field objects, we don't rotate the capture components around the stereo pivot, but instead
//around each capture component
const auto rotAngleOffset = FRotator::ClampAxis(Rotation.Yaw - StartRotation.Yaw);
float eyeSeparationDampeningFactor = 1.0f;
if (rotAngleOffset <= 90.0f)
{
eyeSeparationDampeningFactor = FMath::Lerp(1.0f, 0.0f, rotAngleOffset / 90.0f);
}
else if (rotAngleOffset <= 270.0f)
{
eyeSeparationDampeningFactor = 0.0f;
}
else
{
eyeSeparationDampeningFactor = FMath::Lerp(0.0f, 1.0f, (rotAngleOffset - 270.0f) / 90.0f);
}
Offset = StartRotation.RotateVector(Offset * eyeSeparationDampeningFactor);
}
else
{
Offset = Rotation.RotateVector(Offset);
}
LeftEyeCaptureComponents[CaptureIndex]->SetWorldLocationAndRotation( StartLocation - Offset, Rotation );
LeftEyeCaptureComponents[CaptureIndex]->CaptureSceneDeferred();
RightEyeCaptureComponents[CaptureIndex]->SetWorldLocationAndRotation( StartLocation + Offset, Rotation );
RightEyeCaptureComponents[CaptureIndex]->CaptureSceneDeferred();
}
AActor* UWeaponComponent::PlotHitLine(float LineLength, AController* Instigator, TSubclassOf<UDamageType> DamageType, UGameplaySystemComponent* GameplaySystem)
{
if (this->GetOwner() == nullptr)
return nullptr;
AController* OwnerAsController = dynamic_cast<AController*>(this->GetOwner());
if (OwnerAsController == nullptr)
return nullptr;
if (OwnerAsController->GetPawn() == nullptr)
return nullptr;
FVector TraceStart = OwnerAsController->GetPawn()->GetActorLocation();
FVector TraceEnd = OwnerAsController->GetPawn()->GetActorLocation();
{
FRotator Rotation = OwnerAsController->GetControlRotation();
TraceEnd += Rotation.RotateVector(FVector(LineLength, 0, 0));
}
// Setup the trace query
FCollisionQueryParams TraceParams = FCollisionQueryParams();
TraceParams.AddIgnoredActor(OwnerAsController->GetPawn());
TraceParams.bTraceAsyncScene = true;
FCollisionResponseParams CollisionParams = FCollisionResponseParams();
FHitResult HitResult;
if (this->GetWorld()->LineTraceSingleByChannel(HitResult, TraceStart, TraceEnd, ECC_GameTraceChannel1, TraceParams, CollisionParams))
{
if (GameplaySystem == nullptr)
return nullptr;
APawn* TargetAsPawn = dynamic_cast<APawn*>(HitResult.Actor.Get());
if (TargetAsPawn)
{
TargetAsPawn->GetController()->TakeDamage(GameplaySystem->GetInfightAttackPoints(), FDamageEvent(DamageType), Instigator, Instigator->GetPawn());
}
return HitResult.GetActor();
}
else
{
return nullptr;
}
}
AActor* UWeaponComponent::SpawnProjectile(UClass* ProjectileClass, FVector RelativeSpawnLocation, AActor* LaunchingActor, UGameplaySystemComponent* GameplaySystem)
{
FTransform SpawnTransform;
{
FRotator SpawnRotation = LaunchingActor->GetActorRotation();
FVector SpawnLocation = LaunchingActor->GetActorLocation();
SpawnLocation += SpawnRotation.RotateVector(RelativeSpawnLocation);
SpawnTransform = FTransform(SpawnRotation, SpawnLocation);
}
FActorSpawnParameters SpawnParameters = FActorSpawnParameters();
SpawnParameters.Owner = this->GetOwner();
AActor* SpawnedActor = this->GetWorld()->SpawnActor(ProjectileClass, &SpawnTransform, SpawnParameters);
AProjectile* Projectile = dynamic_cast<AProjectile*>(SpawnedActor);
if (Projectile != nullptr)
{
Projectile->SetAttackPoints(GameplaySystem->GetInfightAttackPoints());
}
return SpawnedActor;
}
bool AWeaponPowerUp::OnShoot_Implementation()
{
// try and fire a projectile
if(ProjectileClass != nullptr)
{
const FRotator SpawnRotation = GetPlayerCube()->GetActorRotation();
// MuzzleOffset is in camera space, so transform it to world space before offsetting from the character location to find the final muzzle position
const FVector OffsetVector(120.0f, 0.0f, 0.0f);
const FVector SpawnLocation = GetPlayerCube()->GetActorLocation() + SpawnRotation.RotateVector(OffsetVector);
UWorld* const World = GetWorld();
if(World != nullptr)
{
// spawn the projectile at the muzzle
AProjectile* projectile = World->SpawnActor<AProjectile>(ProjectileClass, SpawnLocation, SpawnRotation);
projectile->SetInstigator(GetPlayerCube()->GetController());
return true;
}
}
return false;
}
void AWizardsCharacter::OnFire()
{
if (!mySpellBook.IsValidIndex(0)) {
UE_LOG(LogTemp, Warning, TEXT("Spell Gathering Needed!"));
newCharactersSpells();
}
if (Mana > mySpellBook[currSpell].spellCost) {
Mana -= mySpellBook[currSpell].spellCost;
// try and fire a projectile
if (mySpellBook[currSpell].spellType == 0)
{
const FRotator SpawnRotation = GetControlRotation();
const FVector SpawnLocation = GetActorLocation() + SpawnRotation.RotateVector(GunOffset);
UWorld* const World = GetWorld();
if (World)
{
// spawn the projectile at the muzzle
/*UParticleSystem* projParticle = particleList[mySpellBook[currSpell].spellEffect + mySpellBook[currSpell].spellType * 5];
UParticleSystem* blastParticle = particleList[mySpellBook[currSpell].spellEffect + 5];
AWizardsProjectile* wizardsSpell = World->SpawnActor<AWizardsProjectile>(ProjectileClass, SpawnLocation, SpawnRotation);// , myparams);
wizardsSpell->SpellCreation(&mySpellBook[currSpell], projParticle, blastParticle, this);*/
if (Role < ROLE_Authority)
{
ServerFireProjectile(mySpellBook[currSpell], SpawnRotation, SpawnLocation);//mySpellBook[currSpell]);
}
else {
ClientFireProjectile(mySpellBook[currSpell], SpawnRotation, SpawnLocation);
}
}
}
else if (mySpellBook[currSpell].spellType == 1) {
const FRotator SpawnRotation = FRotator(0.0);//GetControlRotation();
// MuzzleOffset is in camera space, so transform it to world space before offsetting from the character location to find the final muzzle position
const FVector SpawnLocation = FVector(0.0);//GetActorLocation() + SpawnRotation.RotateVector(GunOffset);
UWorld* const World = GetWorld();
if (World)
{
// spawn the projectile at the muzzle
/*UParticleSystem* blastParticle = particleList[mySpellBook[currSpell].spellEffect + mySpellBook[currSpell].spellType * 5];
AWizardsBlast* wizardsSpell = World->SpawnActor<AWizardsBlast>(BlastClass, SpawnLocation, SpawnRotation);// , myparams);
wizardsSpell->SpellCreation(blastParticle, mySpellBook[currSpell].spellSize, mySpellBook[currSpell].spellDamage, this);
wizardsSpell->AttachRootComponentTo(GetCapsuleComponent());//Probably useful for Blasts, Rays, and Conical attacks*/
if (Role < ROLE_Authority)
{
ServerFireProjectile(mySpellBook[currSpell], SpawnRotation, SpawnLocation);
}
else {
ClientFireProjectile(mySpellBook[currSpell], SpawnRotation, SpawnLocation);
}
}
}
else if (mySpellBook[currSpell].spellType == 2) {
const FRotator SpawnRotation = FRotator(0.0);//GetControlRotation();
// MuzzleOffset is in camera space, so transform it to world space before offsetting from the character location to find the final muzzle position
const FVector SpawnLocation = FVector(0.0);//GetActorLocation() + SpawnRotation.RotateVector(GunOffset);
UWorld* const World = GetWorld();
if (World)
{
// spawn the projectile at the muzzle
/*UParticleSystem* coneParticle = particleList[mySpellBook[currSpell].spellEffect + mySpellBook[currSpell].spellType * 5];
AWizardsCone* wizardsCone = World->SpawnActor<AWizardsCone>(ConeClass, SpawnLocation, SpawnRotation);// , myparams);
wizardsCone->SpellCreation(coneParticle, mySpellBook[currSpell].spellSize, mySpellBook[currSpell].spellDamage, this);
wizardsCone->AttachRootComponentTo(GetCapsuleComponent());//Probably useful for Blasts, Rays, and Conical attacks
activeAttack = Cast<AActor>(wizardsCone);*/
if (Role < ROLE_Authority)
{
ServerFireProjectile(mySpellBook[currSpell], SpawnRotation, SpawnLocation);
}
else {
ClientFireProjectile(mySpellBook[currSpell], SpawnRotation, SpawnLocation);
}
}
}
// God this sound is so annoying
/*if (FireSound != NULL)
{
UGameplayStatics::PlaySoundAtLocation(this, FireSound, GetActorLocation());
}*/
// try and play a firing animation if specified
if (FireAnimation != NULL)
{
// Get the animation object for the arms mesh
UAnimInstance* AnimInstance = Mesh1P->GetAnimInstance();
if (AnimInstance != NULL)
{
AnimInstance->Montage_Play(FireAnimation, 1.f);
}
}
}
}
FVector UKismetMathLibrary::GreaterGreater_VectorRotator(FVector A, FRotator B)
{
return B.RotateVector(A);
}
void UFlareSpacecraftDockingSystem::Start()
{
// Dock data
int32 Count = 0;
TArray<UActorComponent*> ActorComponents;
Spacecraft->GetComponents(ActorComponents);
// Fill all dock slots
for (TArray<UActorComponent*>::TIterator ComponentIt(ActorComponents); ComponentIt; ++ComponentIt)
{
UFlareStationDock* Component = Cast<UFlareStationDock>(*ComponentIt);
if (Component)
{
// Get data
FVector DockLocation;
FRotator DockRotation;
Component->GetSocketWorldLocationAndRotation(FName("dock"), DockLocation, DockRotation);
// Fill info
FFlareDockingInfo Info;
Info.LocalAxis = Spacecraft->Airframe->GetComponentToWorld().Inverse().GetRotation().RotateVector(DockRotation.RotateVector(FVector(1,0,0)));
Info.LocalLocation = Spacecraft->Airframe->GetComponentToWorld().Inverse().TransformPosition(DockLocation);
Info.DockId = Count;
Info.DockSize = Component->DockSize;
Info.Station = Spacecraft;
Info.Granted = false;
Info.Occupied = false;
// Push this slot
DockingSlots.Add(Info);
Count++;
}
}
}
void UVaOceanBuoyancyComponent::PerformWaveReaction(float DeltaTime)
{
AActor* MyOwner = GetOwner();
if (!UpdatedComponent || MyOwner == NULL)
{
return;
}
UPrimitiveComponent* OldPrimitive = Cast<UPrimitiveComponent>(UpdatedComponent);
const FVector OldLocation = MyOwner->GetActorLocation();
const FRotator OldRotation = MyOwner->GetActorRotation();
const FVector OldLinearVelocity = OldPrimitive->GetPhysicsLinearVelocity();
const FVector OldAngularVelocity = OldPrimitive->GetPhysicsAngularVelocity();
const FVector OldCenterOfMassWorld = OldLocation + OldRotation.RotateVector(COMOffset);
const FVector OwnerScale = MyOwner->GetActorScale();
// XYZ === Throttle, Steering, Rise == Forwards, Sidewards, Upwards
FVector X, Y, Z;
GetAxes(OldRotation, X, Y, Z);
// Process tension dots and get torque from wind/waves
for (FVector TensionDot : TensionDots)
{
// Translate point to world coordinates
FVector TensionDotDisplaced = OldRotation.RotateVector(TensionDot + COMOffset);
FVector TensionDotWorld = OldLocation + TensionDotDisplaced;
// Get point depth
float DotAltitude = GetAltitude(TensionDotWorld);
// Don't process dots above water
if (DotAltitude > 0)
{
continue;
}
// Surface normal (not modified!)
FVector DotSurfaceNormal = GetSurfaceNormal(TensionDotWorld) * GetSurfaceWavesNum();
// Modify normal with real Z value and normalize it
DotSurfaceNormal.Z = GetOceanLevel(TensionDotWorld);
DotSurfaceNormal.Normalize();
// Point dynamic pressure [http://en.wikipedia.org/wiki/Dynamic_pressure]
// rho = 1.03f for ocean water
FVector WaveVelocity = GetWaveVelocity(TensionDotWorld);
float DotQ = 0.515f * FMath::Square(WaveVelocity.Size());
FVector WaveForce = FVector(0.0,0.0,1.0) * DotQ /* DotSurfaceNormal*/ * (-DotAltitude) * TensionDepthFactor;
// We don't want Z to be affected by DotQ
WaveForce.Z /= DotQ;
// Scale to DeltaTime to break FPS addiction
WaveForce *= DeltaTime;
// Apply actor scale
WaveForce *= OwnerScale.X;// *OwnerScale.Y * OwnerScale.Z;
OldPrimitive->AddForceAtLocation(WaveForce * Mass, TensionDotWorld);
}
// Static metacentric forces (can be useful on small waves)
if (bUseMetacentricForces)
{
FVector TensionTorqueResult = FVector(0.0f, 0.0f, 0.0f);
// Calc recovering torque (transverce)
FRotator RollRot = FRotator(0.0f, 0.0f, 0.0f);
RollRot.Roll = OldRotation.Roll;
FVector MetacenterDisplaced = RollRot.RotateVector(TransverseMetacenter + COMOffset);
TensionTorqueResult += X * FVector::DotProduct((TransverseMetacenter - MetacenterDisplaced),
FVector(0.0f, -1.0f, 0.0f)) * TensionTorqueRollFactor;
// Calc recovering torque (longitude)
FRotator PitchRot = FRotator(0.0f, 0.0f, 0.0f);
PitchRot.Pitch = OldRotation.Pitch;
MetacenterDisplaced = PitchRot.RotateVector(LongitudinalMetacenter + COMOffset);
TensionTorqueResult += Y * FVector::DotProduct((LongitudinalMetacenter - MetacenterDisplaced),
FVector(1.0f, 0.0f, 0.0f)) * TensionTorquePitchFactor;
// Apply torque
TensionTorqueResult *= DeltaTime;
TensionTorqueResult *= OwnerScale.X;// *OwnerScale.Y * OwnerScale.Z;
OldPrimitive->AddTorque(TensionTorqueResult);
}
}
void AOutsiderCharacter::OnFire()
{
const FRotator SpawnRotation = GetControlRotation();
// MuzzleOffset is in camera space, so transform it to world space before offsetting from the character location to find the final muzzle position
const FVector SpawnLocation = ((FP_MuzzleLocation != nullptr) ? FP_MuzzleLocation->GetComponentLocation() : GetActorLocation()) + SpawnRotation.RotateVector(GunOffset);
UWorld* const World = GetWorld();
if (World != NULL)
{
// spawn the projectile at the muzzle
World->SpawnActor<AOutsiderProjectile>(AOutsiderProjectile::StaticClass(), SpawnLocation, SpawnRotation);
}
}
bool FSplineComponentVisualizer::HandleInputDelta(FEditorViewportClient* ViewportClient, FViewport* Viewport, FVector& DeltaTranslate, FRotator& DeltaRotate, FVector& DeltaScale)
{
USplineComponent* SplineComp = GetEditedSplineComponent();
if (SplineComp != nullptr)
{
FInterpCurveVector& SplineInfo = SplineComp->SplineInfo;
FInterpCurveQuat& SplineRotInfo = SplineComp->SplineRotInfo;
FInterpCurveVector& SplineScaleInfo = SplineComp->SplineScaleInfo;
const int32 NumPoints = SplineInfo.Points.Num();
if (SelectedTangentHandle != INDEX_NONE)
{
// When tangent handles are manipulated...
check(SelectedTangentHandle < NumPoints);
if (!DeltaTranslate.IsZero())
{
check(SelectedTangentHandleType != ESelectedTangentHandle::None);
SplineComp->Modify();
FInterpCurvePoint<FVector>& EditedPoint = SplineInfo.Points[SelectedTangentHandle];
const FVector Delta = (SelectedTangentHandleType == ESelectedTangentHandle::Leave) ? DeltaTranslate : -DeltaTranslate;
const FVector Tangent = EditedPoint.LeaveTangent + SplineComp->ComponentToWorld.InverseTransformVector(Delta);
EditedPoint.LeaveTangent = Tangent;
EditedPoint.ArriveTangent = Tangent;
EditedPoint.InterpMode = CIM_CurveUser;
}
}
else
{
// When spline keys are manipulated...
check(LastKeyIndexSelected != INDEX_NONE);
check(LastKeyIndexSelected < NumPoints);
check(SelectedKeys.Num() > 0);
SplineComp->Modify();
if (ViewportClient->IsAltPressed() && bAllowDuplication)
{
OnDuplicateKey();
// Don't duplicate again until we release LMB
bAllowDuplication = false;
}
for (int32 SelectedKeyIndex : SelectedKeys)
{
FInterpCurvePoint<FVector>& EditedPoint = SplineInfo.Points[SelectedKeyIndex];
FInterpCurvePoint<FQuat>& EditedRotPoint = SplineRotInfo.Points[SelectedKeyIndex];
FInterpCurvePoint<FVector>& EditedScalePoint = SplineScaleInfo.Points[SelectedKeyIndex];
if (!DeltaTranslate.IsZero())
{
// Find key position in world space
const FVector CurrentWorldPos = SplineComp->ComponentToWorld.TransformPosition(EditedPoint.OutVal);
// Move in world space
const FVector NewWorldPos = CurrentWorldPos + DeltaTranslate;
// Convert back to local space
EditedPoint.OutVal = SplineComp->ComponentToWorld.InverseTransformPosition(NewWorldPos);
}
if (!DeltaRotate.IsZero())
{
// Set point tangent as user controlled
EditedPoint.InterpMode = CIM_CurveUser;
// Rotate tangent according to delta rotation
FVector NewTangent = SplineComp->ComponentToWorld.GetRotation().RotateVector(EditedPoint.LeaveTangent); // convert local-space tangent vector to world-space
NewTangent = DeltaRotate.RotateVector(NewTangent); // apply world-space delta rotation to world-space tangent
NewTangent = SplineComp->ComponentToWorld.GetRotation().Inverse().RotateVector(NewTangent); // convert world-space tangent vector back into local-space
EditedPoint.LeaveTangent = NewTangent;
EditedPoint.ArriveTangent = NewTangent;
// Rotate spline rotation according to delta rotation
FQuat NewRot = SplineComp->ComponentToWorld.GetRotation() * EditedRotPoint.OutVal; // convert local-space rotation to world-space
NewRot = DeltaRotate.Quaternion() * NewRot; // apply world-space rotation
NewRot = SplineComp->ComponentToWorld.GetRotation().Inverse() * NewRot; // convert world-space rotation to local-space
EditedRotPoint.OutVal = NewRot;
}
if (DeltaScale.X != 0.0f)
{
// Set point tangent as user controlled
EditedPoint.InterpMode = CIM_CurveUser;
const FVector NewTangent = EditedPoint.LeaveTangent * (1.0f + DeltaScale.X);
EditedPoint.LeaveTangent = NewTangent;
EditedPoint.ArriveTangent = NewTangent;
}
if (DeltaScale.Y != 0.0f)
{
// Scale in Y adjusts the scale spline
EditedScalePoint.OutVal.Y *= (1.0f + DeltaScale.Y);
}
if (DeltaScale.Z != 0.0f)
{
// Scale in Z adjusts the scale spline
EditedScalePoint.OutVal.Z *= (1.0f + DeltaScale.Z);
}
}
}
NotifyComponentModified();
return true;
}
return false;
}
void UJanusExporterTool::Export()
{
TArray<UObject*> ObjectsToExport;
FString Root = FString(ExportPath); // copy so we dont mess with the original reference
FString Index = "<html>\n\t<head>\n\t\t<title>Unreal Export</title>\n\t</head>\n\t<body>\n\t\t<FireBoxRoom>\n\t\t\t<Assets>";
TArray<AActor*> ActorsExported;
TArray<UStaticMesh*> StaticMeshesExp;
TArray<FString> TexturesExp;
TArray<FString> MaterialsExported;
for (TObjectIterator<AActor> Itr; Itr; ++Itr)
{
AActor *Actor = *Itr;
FString Name = Actor->GetName();
/*if (!Name.StartsWith("SM_Floor_R"))
{
continue;
}*/
if (Actor->IsHiddenEd())
{
continue;
}
ActorsExported.Add(Actor);
TArray<UStaticMeshComponent*> StaticMeshes;
Actor->GetComponents<UStaticMeshComponent>(StaticMeshes);
for (int32 i = 0; i < StaticMeshes.Num(); i++)
{
UStaticMeshComponent* Component = StaticMeshes[i];
UStaticMesh *Mesh = Component->StaticMesh;
if (!Mesh)
{
continue;
}
if (Component->LODData.Num() > 0)
//if (false)
{
FStaticMeshComponentLODInfo* LODInfo = &Component->LODData[0];
FLightMap* LightMap = LODInfo->LightMap;
FShadowMap* ShadowMap = LODInfo->ShadowMap;
if (LightMap != NULL)
{
FLightMap2D* LightMap2D = LightMap->GetLightMap2D();
UTexture2D* Texture = LightMap2D->GetTexture(0); // 0 = HQ LightMap
FString TexName = Texture->GetName();
if (TexturesExp.Contains(TexName))
{
continue;
}
TexturesExp.Add(TexName);
ExportPNG(Texture, Root);
}
if (ShadowMap != NULL)
{
FShadowMap2D* ShadowMap2D = ShadowMap->GetShadowMap2D();
UShadowMapTexture2D* ShadowTex = ShadowMap2D->GetTexture();
FString TexName = ShadowTex->GetName();
if (TexturesExp.Contains(TexName))
{
continue;
}
TexturesExp.Add(TexName);
ExportPNG(ShadowTex, Root);
}
}
if (!StaticMeshesExp.Contains(Mesh))
{
StaticMeshesExp.Add(Mesh);
ExportFBX(Mesh, Root);
}
TArray<UMaterialInterface*> Materials = Component->GetMaterials();
for (int32 j = 0; j < Materials.Num(); j++)
{
UMaterialInterface* Material = Materials[j];
if (!Material)
{
continue;
}
FString MatName = Material->GetName();
if (MaterialsExported.Contains(MatName))
{
continue;
}
MaterialsExported.Add(MatName);
ExportMaterial(Root, Material, &TexturesExp);
}
}
}
// Models before textures so we can start showing the scene faster (textures take too long to load)
for (int32 i = 0; i < StaticMeshesExp.Num(); i++)
{
UStaticMesh *mesh = StaticMeshesExp[i];
Index.Append("\n\t\t\t\t<AssetObject id=\"" + mesh->GetName() + "\" src=\"" + mesh->GetName() + ".fbx\" />");
}
for (int32 i = 0; i < TexturesExp.Num(); i++)
{
FString Path = TexturesExp[i];
Index.Append("\n\t\t\t\t<AssetImage id=\"" + Path + "\" src=\"" + Path + ".png\" />");
}
Index.Append("\n\t\t\t</Assets>\n\t\t\t<Room>");
for (int32 i = 0; i < ActorsExported.Num(); i++)
{
AActor *Actor = ActorsExported[i];
TArray<UStaticMeshComponent*> StaticMeshes;
Actor->GetComponents<UStaticMeshComponent>(StaticMeshes);
for (int32 i = 0; i < StaticMeshes.Num(); i++)
{
UStaticMeshComponent* Component = StaticMeshes[i];
UStaticMesh *Mesh = Component->StaticMesh;
if (!Mesh)
{
continue;
}
FString ImageID = "";
TArray<UMaterialInterface*> Materials = Component->GetMaterials();
for (int32 j = 0; j < Materials.Num(); j++)
{
UMaterialInterface* Material = Materials[j];
if (!Material)
{
continue;
}
ImageID = Material->GetName() + "_BaseColor";
break;
}
if (ImageID == "")
{
Index.Append("\n\t\t\t\t<Object collision_id=\"" + Mesh->GetName() + "\" id=\"" + Mesh->GetName() + "\" lighting=\"true\" pos=\"");
}
else
{
Index.Append("\n\t\t\t\t<Object collision_id=\"" + Mesh->GetName() + "\" id=\"" + Mesh->GetName() + "\" image_id=\"" + ImageID + "\" lighting=\"true\" pos=\"");
}
FRotator Rot = Actor->GetActorRotation();
FVector XDir = Rot.RotateVector(FVector::RightVector);
FVector YDir = Rot.RotateVector(FVector::UpVector);
FVector ZDir = Rot.RotateVector(FVector::ForwardVector);
FVector Pos = Actor->GetActorLocation() * UniformScale;
FVector Sca = Actor->GetActorScale();
Pos = ChangeSpace(Pos);
Sca = ChangeSpaceScalar(Sca) * UniformScale;
XDir = ChangeSpace(XDir);
YDir = ChangeSpace(YDir);
ZDir = ChangeSpace(ZDir);
FVector Sign = GetSignVector(Sca);
Index.Append(FString::SanitizeFloat(Pos.X) + " " + FString::SanitizeFloat(Pos.Y) + " " + FString::SanitizeFloat(Pos.Z));
if (Sca.X < 0 || Sca.Y < 0 || Sca.Z < 0)
{
Index.Append("\" cull_face=\"front");
}
Index.Append("\" scale=\"");
Index.Append(FString::SanitizeFloat(Sca.X) + " " + FString::SanitizeFloat(Sca.Y) + " " + FString::SanitizeFloat(Sca.Z));
Index.Append("\" xdir=\"");
Index.Append(FString::SanitizeFloat(XDir.X) + " " + FString::SanitizeFloat(XDir.Y) + " " + FString::SanitizeFloat(XDir.Z));
Index.Append("\" ydir=\"");
Index.Append(FString::SanitizeFloat(YDir.X) + " " + FString::SanitizeFloat(YDir.Y) + " " + FString::SanitizeFloat(YDir.Z));
Index.Append("\" zdir=\"");
Index.Append(FString::SanitizeFloat(ZDir.X) + " " + FString::SanitizeFloat(ZDir.Y) + " " + FString::SanitizeFloat(ZDir.Z));
Index.Append("\" />");
}
}
Index.Append("\n\t\t\t</Room>\n\t\t</FireBoxRoom>\n\t</body>\n</html>");
FString IndexPath = FString(ExportPath).Append("index.html");
FFileHelper::SaveStringToFile(Index, *IndexPath);
}