InstancedActor.h

Go to the documentation of this file.

// Copyright (c) 2023 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Engine/EngineTypes.h"
#include "Engine/StaticMesh.h"
#include "Components/StaticMeshComponent.h"
#include "Internationalization/Text.h"
 
#include "Agrarsense/ActorInterfaces/ActorInformation.h"
#include "Agrarsense/ActorInterfaces/Interactable.h"
#include "Agrarsense/ActorInterfaces/Destroyable.h"
 
#include "InstancedActor.generated.h"
 
UCLASS()
class AGRARSENSE_API AInstancedActor : public AActor, public IInteractable, public IDestroyable, public IActorInformation
{
    GENERATED_BODY()
 
public:
 
    AInstancedActor(const FObjectInitializer& ObjectInitializer);
 
    virtual void BeginPlay() override;
 
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    UFUNCTION(BlueprintCallable)
    bool AddToInstancedRendering();
 
 
    void InstanceAdded();
 
    UFUNCTION(BlueprintCallable)
    void SetTypeAndModel(const FString& Type, const FString& Model)
    {
        TypeID = Type;
        ModelID = Model;
    }
 
    /*
    * Get whether this actor is a tree.
    */
    UFUNCTION(BlueprintCallable)
    bool IsTreeActor() const;
 
    void UpdatePreviousTransform(const FTransform& NewTransform)
    {
        PreviousTransform = NewTransform;
    }
 
    UFUNCTION(BlueprintPure)
    bool IsAddedToInstancedRendering() const
    {
        return AddedToInstancedRenderer;
    }
 
    UFUNCTION(BlueprintPure)
    UStaticMeshComponent* GetStaticMeshComponent() const
    {
        return StaticMeshComponent;
    }
 
    UFUNCTION(BlueprintPure)
    int32 GetInstanceStartCullDistance() const
    {
        return InstanceStartCullDistanceInCm;
    }
 
    UFUNCTION(BlueprintPure)
    int32 GetInstanceEndCullDistance() const
    {
        return InstanceEndCullDistanceInCm;
    }
 
    UFUNCTION(BlueprintPure)
    bool UpdateTransformAutomatically() const
    {
        return ShouldUpdateTransformAutomatically;
    }
 
    UFUNCTION(BlueprintCallable)
    FString GetTypeIDString() const
    {
        return TypeID;
    }
 
    UFUNCTION(BlueprintCallable)
    FString GetModelIDString() const
    {
        return ModelID;
    }
 
    bool HasAlternativeMaterial() const
    {
        return AlternativeMaterial;
    }
 
    bool IsCustomDepthSetup() const
    {
        return CustomDepthSetup;
    }
 
    bool GetAllowWorldPositionOffsetDisable() const
    {
        return AllowWorldPositionOffsetDisable;
    }
 
    FTransform GetPreviousTransform() const
    {
        return PreviousTransform;
    }
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category = "AInstancedActor")
    UStaticMeshComponent* StaticMeshComponent = nullptr;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AInstancedActor")
    bool AllowWorldPositionOffsetDisable = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AInstancedActor")
    bool AddToInstancedRenderer = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AInstancedActor")
    int InstanceStartCullDistanceInCm = 45000;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AInstancedActor")
    int InstanceEndCullDistanceInCm = 46500;
 
    // Should this actor transform be automatically updated (more expensive)
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AInstancedActor")
    bool ShouldUpdateTransformAutomatically = false;
 
    // If we have multiple actors with same mesh but with different material(s), this should be set to true!
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AInstancedActor")
    bool AlternativeMaterial = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AInstancedActor")
    FText InteractableName;
 
    virtual FText GetInteractableName_Implementation() const override
    {
        return InteractableName;
    }
 
    virtual FTransform GetInteractableWorldTransform_Implementation() const override
    {
        return GetActorTransform();
    }
 
    virtual FString GetActorID_Implementation() const override
    {
        return ActorID;
    }
 
    virtual FString GetActorName_Implementation() const override
    {
        return ActorName;
    }
 
    virtual void SetActorName_Implementation(const FString& NewActorName) override
    {
        ActorName = NewActorName;
    }
 
    virtual void SetActorIDAndName_Implementation(const FString& NewActorName, const FString& NewID) override
    {
        ActorName = NewActorName;
        ActorID = NewID;
        SetAndValidateActorIDAndName(ActorName, ActorID, TWeakObjectPtr<AActor>(this));
    }
 
private:
 
    UPROPERTY(VisibleAnywhere)
    FString ActorName;
 
    UPROPERTY(VisibleAnywhere)
    FString ActorID;
 
    FTransform PreviousTransform;
 
    bool AddedToInstancedRenderer = false;
 
    FString TypeID = "none";
 
    FString ModelID = "none";
 
    bool CustomDepthSetup = false;
 
};