Some notes on Using C++ in Unreal

• A macro is a fragment of code which has been given a name.
  • Casual use of macros is discoraged, as they can be dangerous if not use properly.
  • But they are useful if used properly.
  • They are part of the c preprocessor.
  • #define MAX 100
    • Will replace MAX with 100 everywhere in the code.
    • Notice no ;, we dont want to put 100; everywhere.
  • #define MIN(a,b) (((a)<(b)) ? a : b)
• Creating a C++ class gives opens the class visual studio
• I suspect that you can do this in another development environment as well (as she mentions it)
• It creates a .h and .cpp file for you.
• These are subclasses
• Here is a .h file, modified somewhat while working on the tutorial.

  // Fill out your copyright notice in the Description page of Project Settings.
  
  #pragma once
  
  #include "GameFramework/Actor.h"
  #include "Pickup.generated.h"
  
  UCLASS()
  class BATTERYCOLLECTOR_API APickup : public AActor
  {
  	GENERATED_BODY()
  	
  public:	
  	// Sets default values for this actor's properties
  	APickup();
  
  	// Called when the game starts or when spawned
  	virtual void BeginPlay() override;
  	
  	// Called every frame
  	virtual void Tick( float DeltaSeconds ) override;
  
  	// return the mesh for the pickup
  	FORCEINLINE class UStaticMeshComponent* GetMesh() const { return PickupMesh; }
  
  	// return th value of bIsActive
  	UFUNCTION(BlueprintPure, Category="Pickup")
  	bool IsActive();
  
  	// set the value of bIsActive
  	UFUNCTION(BlueprintCallable, Category="Pickup")
  	void SetActive(bool NewPickupState);
  
  protected:
  	//  true when the pickup can be used
  	bool bIsActive;
  
  private:
  	// static mesh to represent the pickup in the level*/
  	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category= "Pickup", meta=(AllowPrivateAccess= true))
  	class UStaticMeshComponent * PickupMesh;
  };
     

  • UFUNCTION and FORCEINLINE
    • These are C macros that expose the function or item to Blueprint scripts.
    • A Function declaration manual for unreal
    • She covers BlueprintPure and BlueprintCallable in the video

    • 	UFUNCTION(BlueprintPure, Category="Pickup")
      	bool IsActive();
      
      	UFUNCTION(BlueprintCallable, Category="Pickup")
      	void SetActive(bool NewPickupState);
      	

    • But it seems BluprintPure is an observer, it does not change the object
    • And BlueprintCallable is a transformer.
    • Category tells the Blueprint where to put it in the node list.
    • FORCEINLINE makes an inline function, it seems equivelent to inline.

    • 	FORCEINLINE class UStaticMeshComponent* GetMesh() const { return PickupMesh; }
      	

    • Here both IsActive and SetActive will have blueprint nodes created for them.
  • UPROPERTY
    • A reference
    • Marks a variable to be exposed to Blueprint
    • VisibleAnywhere: the property can be seen.
    • BlueprintReadOnly: the property can be read, but not modified.

      UPROPERTY(EditAnywhere, Category="Spawning")
      TSubclassOf WhatToSpawn;
      	  

    • Notice the diffference.
• And a .cpp file, modified somewhat while working on the tutorial.

  // Fill out your copyright notice in the Description page of Project Settings.
  
  #include "BatteryCollector.h"
  #include "Pickup.h"
  
  
  // Sets default values
  APickup::APickup()
  {
   	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
  	PrimaryActorTick.bCanEverTick = false;
  
  	// all pickups start active.
  	bIsActive = true;
  
  	// create the static mesh component
  	PickupMesh = CreateDefaultSubobject(TEXT("PickupMesh"));
  	RootComponent = PickupMesh;
  }
  
  // Called when the game starts or when spawned
  void APickup::BeginPlay()
  {
  	Super::BeginPlay();
  }
  
  // Called every frame
  void APickup::Tick( float DeltaTime )
  {
  	Super::Tick( DeltaTime );
  }
  
  
  // return active state
  bool APickup::IsActive() {
  	return bIsActive;
  }
  
  // change active state.
  void APickup::SetActive(bool NewPickupState) {
  	bIsActive = NewPickupState;
  	return;
  }
     

• Notice the setting of RootComponent.