My unreal engine code wont compile

Development Programming & Scripting C++
, , , , , , , , , , , ,
12

you will typically put the include in the earliest header or implementation file that it is needed, and for the header for classes we can use forward-declarations so that we can put the actual include in the implementation file (the .cpp):
lets say I have the following header the implementations should be evident.

//MyActorComponent.h

#pragma once

#include "CoreMinimal.h"
#include "Components/ActorComponent.h"

#include  "MyActorComponent.generated.h"

USTRUCT(BlueprintType)
struct FMyActorComponentStruct
{
    GENERATED_BODY()
//...
};

UCLASS(BlueprintType, Blueprintable, meta=(BlueprintSpawnableComponent))
class MYGAME_API UMyActorComponent : public UActorComponent
{
    GENERATED_BODY()
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    FMyActorComponentStruct ComponentStruct;

    UFUNCTION(BlueprintCallable)
    FMyActorComponentStruct GetComponentStruct();
//...
};

if I wanted to have another class lets say some Manager that wants had a function to receive the struct explicitly (not using the getter I created.

// MyComponentManager
#pragma once

#include "CoreMinimal.h"
#include "MyActorComponent.h" // this is needed because I want to have the struct explicitly
#include "MyComponentManager.generated.h"

UCLASS(BlueprintType, Blueprintable, meta=(BlueprintSpawnableComponent))
class MYGAME_API AMyComponentManager
{
    GENERATED_BODY()
public:
    UFUNCTION(BlueprintCallable)
    void DoWorkwithComponentStructs( FMyActorComponentStruct& componentStructs);
// ...
};

in this formulation I must include the header file that holds the struct type because under Unreal engine structs especially USTRUCT cannot be forward declared (under C++ standards forward declaring structs is allowed but should be avoided if possible)

alternatively I could have

/ MyComponentManager
#pragma once

#include "CoreMinimal.h"
#include "MyComponentManager.generated.h"

UCLASS(BlueprintType, Blueprintable, meta=(BlueprintSpawnableComponent))
class MYGAME_API AMyComponentManager
{
    GENERATED_BODY()
public:
    // because I forward declare the class and receive the pointer I do not need to include the header for the class in this header.
    UFUNCTION(BlueprintCallable)
    void DoWorkwithComponentStructs( class UMyActorComponent* componentThatHoldsStructs);
// ...
};

-keep in mind that I still need to include MyActorComponent.h in the MyComponentManager.cpp

On the matter at hand:
you will need to include the header that containing the definition of FTextureBuildSetters in the header if they are meant to be used in a function or member variable of the class if you intend to use it or have it received out right, or maybe you can have an intermediary container class to get to the given struct.

-For more details I would need to see a rough skeleton of the setup for where to include the file holding the struct

  1. for overriding a virtual function:
  • A virtual function is “typically” defined in an interface (you can technically define a virtual an any class at any point along inheritance, where it mostly signifies intent that “this shall be re-implemented in the inheriting class”
  • keyword override must be paired with keyword virtual (otherwise override is not needed, and will actually throw an error) just re-implementing a non virtual function is valid and is treated differently when the object code is generated.
  • the signature must match exactly: name, argument types and modifiers, and argument order. (the name of arguments “technically never” matters, and when separating declaration and implementation only exist in the function declaration for human readability)

Lets say I have a UMyActorComponent : public UActorComponent and then I wanted to give am implementation of PostEditChangeProperty() (so that when I change something in the editor then I can make changes to other members), and SetVisibility().

for PostEditChangeProperty():
-it must go inside a pre-processor block for #ifdef WITH_EDITOR (otherwise I will fail the cooking process)
-I need to copy the signature exactly (this is one of the few advantages that Rider has of Visual Studio, but it would be an intelli-Sense update) often I will go to the parent class by selected the inheriting the class name and right-click->Go To Definition then searching for the function name and copying that

for SetVisibility()
-I only need to copy the function signature to then be able to re-implement the function and catch calls to it.

So I would end up with

public:
#if WITH_EDITOR // #ifdef is also valid
    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif
    void SetVisibility(bool bNewVisibility, bool bPropagateToChildren=false);

I can then utilize the engines Super:: parent class resolution system to be to the next highest implementation if I do not want to just replace it outright (this is considered simultaneously a strong point and weak point of Object-Oriented-Programming based on trust of re-implantation potential