"bir yazılımcının not defteri.."

17 Aralık 2017 Pazar

Unreal Engine Programlama Temelleri 3 - Sınıf Yaratma Temelleri

selamlar,

bu yazımızda Unreal Engine deki Class yaratma şekillerini inceleyeceğiz; ve bir örnek ile uygulayacağız.

Örneğimiz bir ışık actor ünün extra özellik katılmış şekli olacak; yapacağımız şey aslında basit; bir açma kapama düğmesi ile kontrol edilebilen bir ışık; bittiğinde inşallah şuna benzeyecek:



ilk örnekte sadece Blueprint kullanarak Actor ümüzü elde edeceğiz, birinde ise hem C++ hem Blueprint i ortaklaşa kullanacağız, son örnekte ise sadece C++ kullanarak aynı Actor ün nasıl elde edileceğini göreceğiz.

Bu class lar doğrudan Actor temellidir; çünkü sahneye yerleştirilmeleri gerekecektir; malzeme olarak bir adet PointLightComponent içermesi gerekecek bi kere; çünkü işin içinde ışık var malumunuz; ve bu component root component olacak;  yani eklenecek diğer component ler ona attach lanacak.

ihtiyacımız olan bir başka component ise SphereComponent olacak; yani küre; küre ne alakası var derseniz senaryomuz gereği belli bir alanın içine girildiğinde açılan, çıkıldığında kapanan ışık istiyoruz; işte küre component i bu kontrollü alanı sağlayacak; 

son olarak ışık yoğunluğunun parametrik olmasını istiyoruz; yani ışık yoğunluğunun dinamik olması ve sonradan değiştirebilmesi için, hatta Editör den ayarlanabilir olması, ve hatta gameplay anında değişebilen olması açısından da onu ayrı bir değiken ile ifade edelim; bu yüzden DesiredIntensity adında float tipinde bir değişken ekleyelim; bu değişken az önce de söylediğim gibi ışık component inden yayılan ışığın yoğunluğunu ayarlayabilmemizi sağlayacak; kodlamasını birazdan yapacağız.




Sadece Blueprint ile:
Blueprint görsel bir ortamda kodlama yapmamıza olanak tanıyan harika bir sistemdir; ürettiğimiz class lara component ler ekleyebilir, ve hatta fonksyonlar yazabilir ve tüm diğer gameplay davranışlarını tasarlayabiliriz. Blueprint ile yaratacağımız class ın ismini LightSwitch_BPOnly koyacağız;

e hadi başlayalım,

önce Content Brıwser dan LightSwitch_BPOnly class ını yaratalım parent class olarak Actor seçelim;

Component ler Blueprint ortamına static olarak, veya Blueprint editörün deki Components Tabından, veyahutta graph editöründen dinamik olarak da eklenebilir. Bizim şu LightSwitch class ımız iki ayrı componente sahip olacak  bunlardan biri ışık componenti olan PointLightComponent, diğeri ise alan volümü sağlayan SphereComponent olacak demiştik. Onları Components tabından static olarak ekleyelim.



Eklendiklerinde PointLight1 ve Sphere1 adlarını aldılar (object olarak). 

Bu arada PointLight1 class ın RootComponent i oldu ve Sphere1 component objet i PointLight1 e attach lendi. 

Blueprint editör içinden yeni değişkenler (variables), fonksyonlar ve hatta maksrolar dahi ekleyebilirsiniz. Graph ekranı içinde nodları birbirine bağlayarak kod akışı yaratabilirsiniz. 

şimdi DesiredIntensity adında bir float tipinde değişken yaratalım.



Class ın yapıcı fonksyonunu (Construction Script) aşağıdaki gibi programlayalım;

yapıcı fonksyon, Actor level e eklendiği ya da varolan Actor level içinde hareket ettiği anda tetiklenir;

aşağıda, yapıcı fonksyon başlangıçö nodu Set Intensity noduna bağlanıyor; böylece Point Light 1 in Intensity değeri DesiredIntensity değişkeninin değeri ile eşitleniyor; ve bu tam olarak Actor level e eklendiği yada level içnide hareket ettiği anda yapılıyor.



eventgraph içindeki OnComponentBeginOverlap ve OnComponentEndOverlap gibi event lere de değişik nodlar bağlanabilir; bu evet ler (olaylar) SphereComponent e level içindeki diğer Actor lerin overlap olması veya overlap durumundan çıkması durumlarında tetiklenecektir; böylece biz de onları yakalayabilir ve görsel kod ekleyebiliriz;

her iki olay da Toggle Visibility noduna bağlanıyor böylece PointLightComponent inin görünürlüğü bu duruma göre değişebilir kılınıyor.



OnComponentEndOverlap nodunu eklerken önce Sphere1 in seçili durumda olduğuna enim olunuz; ve seçili olan objeye Event -> Add Event diyerek veyahutta doğrudan graph a sağ tıklayıp Add Event -> Collision -> View OnComponentBeginOverlap / OnComponentEndOverlap seçilerek ilgili event ekleyebiliriz.

DesiredIntensity değişkeni eidtör içinde edit edilebilir durumdadır; bunun class default değerini verebiliriz / değiştirebilriz; bunun anlamı bu değişkenin (variable) değerinin class ın her bir object instance inde ayrı ayrı değişebileceğidir; burada sözü edilen özellikle belirtilmez ise ayarlanacak olan class default değeridir; ancak elbetteki her Actor kendi DesiredIntensity değişkenine sahip olacaktır.



Blueprint class ları başka Blueprint  class larından extend edilebilir, yani miras alınabilir, Clss Viewer daki drop down kullanılarak diğer class lara bakabiliriz ve seçtikten sonra Create New Blueprint Based on This diyerek bunu kolaylıkla yapabiliriz.





C++ ve Blueprint Kullanarak :
C++ sınıfları Blueprint den extend edilebilir yani miras alınabilir; böylece programcıların yazdığı gameplay objelerinin level designer lar tarafından alınıp geliştirebilmesi mümkün olur. Bir C++ class ının Blueprint sistemi ile nasıl etkileşeceğinin belirlenmesi / değiştirilebilmesi için yine bir dizi belirleçler (specifiers) vardır, bu yazıda bazılarını inceleyeceğiz.

şimdi yukarıdaki aynı Class ı C++ ile üretmeyi deneyelim; eğer C++ code only yöntemi ile üretilmiş bir class ı eğer gerekli specifiers ler konmamış ise üyelerine (components, variables, functions) Blueprint ortamından erişemeyiz.

bu örnekte biz UPROPERTY() ve UFUNCTION() specifiers üzerinde duracağız bu iki belirteç ilgili üyeyi onu devralan Blueprint sınıfından ulaşılabilir yapacak.

Örneğimizde SphereComponent ve PointLightComponent lerin her ikisi de BlueprintReadOnly olarak işaretlenmiştir; ve aynı makroya göre My Blueprint tabı altında "Switch Components" kategorisi altnda artık görüneceklerdir.

OnOverlapBegin ve OnOverlapEnd olayları da BlueprintNativeEvents olarak işaretlendiğinden ve yine ilgili belirteç gereği My Blueprint tabı içindeki Switch Functions kategorisi altında listeleneceklerdir.

DesiredIntensity değişkeni de kodda görüleceği üzere BlueprintReadWrite olarak belirtilmiştir ve o da My Blueprint tabı altında Switch Variables kategorisi altında artık hem görünecek hem de Blueprint  ortamından değeri değiştirilebilecektir; ve yine bu değişken için VisibleAnywhere yerine EditAnywhere görünüm belirteci kullanılmıştır.

UCLASS() makrosu da aslnda yine Blueprint ile ilgili, UCLASS() ile yarattığımız class ı Blueprint ortamından devralınabilir, ve Blueprint ortamından bu class ı manüpule edilebilir (Blueprintable) kılıyoruz; fakat bizim aşağıdaki durumda şart değildir çünkü LightSwitchBoth class ı zaten Blueprintable olan Actor class ından doğrudan miras alınmıştır; dolayısı ile Blueprintable göstergeci de miras alınmıştır.

ilave olarak UPROPERTY() ve UFUNCTION() maktoları aşağıdaki gibi kullanılmıştır:

LightSwitchBoth.h
    // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.

    #pragma once

    #include "GameFramework/Actor.h"
    #include "LightSwitchBoth.generated.h"

    /**
     * 
     */
    UCLASS()
    class [PROJECTNAME]_API ALightSwitchBoth : public AActor
    {
        GENERATED_BODY()
        public:
        /** point light component */
        UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Switch Components")
        class UPointLightComponent* PointLight1;

        /** sphere component */
        UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Switch Components")
        class USphereComponent* Sphere1;

        ALightSwitchBoth();

        /** called when something enters the sphere component */
        UFUNCTION(BlueprintNativeEvent, Category="Switch Functions")
        void OnOverlapBegin(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);

        void OnOverlapBegin_Implementation(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);

        /** called when something leaves the sphere component */
        UFUNCTION(BlueprintNativeEvent, Category="Switch Functions")
        void OnOverlapEnd(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex);

        void OnOverlapEnd_Implementation(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex);

        /** Toggles the light component's visibility*/
        UFUNCTION()
        void ToggleLight();

        /** the desired intensity for the light */
        UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Switch Variables")
        float DesiredIntensity;

    };

LightSwitchBoth in yapıcı fonksyonu aynı kaldı; fakat, OnOverlapBegin ve OnOverlapEnd fonksyonlarında biraz değişiklik lazım. Bu fonksyonlar artık birer BlueprintNativeEvent idirler. Bunun anlamı, bu sınıftan türetilen bir Blueprint'te, OnOverlapBegin ve OnOverlapEnd öğelerini geçersiz kılmak için olaylar yerleştirilebilir ve bu işlevler normal olarak çağrıldığında çalıştırılır.

Eğer bu event lerden biri mevcut değilse, onun yerine C++ fonksyon implemantasyonu geçer. Elbette bu kurulumun çalışması için C++ fonksyonlarının yeniden adlandırılması gerekir; bunlar da OnOverlapBegin_Implementation ve OnOverlapEnd_Implementation şeklinde olur. Daha sonraki Blueprint kurulumunda bu örneklenecektir. OnOverlapBegin ve OnOverlapEnd tanımlamalarını değiştirerek LightSwitchBoth kodunun son hali şöyledir:


LightSwitchBoth.cpp
// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.

#include "BasicClasses.h"
#include "LightSwitchBoth.h"

ALightSwitchBoth::ALightSwitchBoth()
{

    DesiredIntensity = 3000.0f;

    PointLight1 = CreateDefaultSubobject<UPointLightComponent>(TEXT("PointLight1"));
    PointLight1->Intensity = DesiredIntensity;
    PointLight1->bVisible = true;
    RootComponent = PointLight1;

    Sphere1 = CreateDefaultSubobject<USphereComponent>(this, TEXT("Sphere1"));
    Sphere1->InitSphereRadius(250.0f);
    Sphere1->SetupAttachment(RootComponent);

    Sphere1->OnComponentBeginOverlap.AddDynamic(this, &ALightSwitchBoth::OnOverlapBegin);       // set up a notification for when this component overlaps something
    Sphere1->OnComponentEndOverlap.AddDynamic(this, &ALightSwitchBoth::OnOverlapEnd);       // set up a notification for when this component overlaps something
}

void ALightSwitchBoth::OnOverlapBegin_Implementation(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
    if (OtherActor && (OtherActor != this) && OtherComp)
    {
        ToggleLight();
    }
}

void ALightSwitchBoth::OnOverlapEnd_Implementation(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
    if (OtherActor && (OtherActor != this) && OtherComp)
    {
        ToggleLight();
    }
}

void ALightSwitchBoth::ToggleLight()
{
    PointLight1->ToggleVisibility();
}

bu boş projeye eklediğimiz ilk kod class ıdır; game modülünün düzgün yüklendiğine emin olmak için unreal editörü kapamamız, Visaual Studio da propjeyi derleyip editörü tekrar açmamız gerekebilir. Dahası Build Configuration ın unreal editördeki açık olan projeninki ile uyumlu olduğuna emin olun.

Eğer varolan bir C++ projesine kod ekliyorsanız yeni kodu enreal editörü içinde derlemek için “Hot Reload“ işlevini kullanmanız gerekir.

bu class ı derlemenin ardından onu miras alarak yeni Blueprint class ı yaratmak mümkündür; elbette Blueprint editörde Create New Class sihirbazını başlatıp LightSwitchBoth ı parent class olarak seçmek gerekir. Yeni yaratılan Blueprint class ına da LightSwitchBoth_BP adını verelim:



görüüleceği üzere PointLightComponent ve SphereComponent BP nin components kısmında artık mavi olarak görülüyor. Bunun anlamı onların LightSwitchBoth class ından mrias alınmış native components olmasıdır. Artık yeni eklenecek yeni componentler de buz mavisi en üst ikona eklenecektir.



Blueprint grap ı ortamından yeni değişkenler (variables), fonksyonlar ve makrolar ekleyebiliriz, ve tüm diğer class lara erişebiliriz,










aşağıdaki resimde Construction Script grafikal nodlar ile kodlanıyor; eğer bu Blueprint ortamında hiç yazılmaz ise base class tan gelen LightSwitchBoth in yapıcı (constructor) fonksyonu çalışacaktır.

Burada bu yapıcı fonksyon ışığın (Point Light 1) Intensity değerini set ediyor; bunu DesiredIntensity değişkenindeki değeri atayarak yapıyor; ve tam da bu işlem yapıcı fonksyonun içinde yani class ile üretilmiş olan Actor level de oluştuğunda yada level içinde hareket ettiği anda bu minik grafiksel kod koşacak ve ışığın yoğunluğu ayarlanacak demektir.



devam eden graph kodlarında OnOverlap event i kodlanıyor. OnOverlap , LightSwitchBoth C++ kaynak dosyasındaki OnOverlap fonksyonu çağrıldığında tetiklenecektir. Burada bir Actor ün SphereComponent in alanına girmesi veya terketmesi durumuna bağlı olarak tetiklenen OnOverlap delegasyonu vardır.

    Sphere1->OnComponentBeginOverlap.AddDynamic(this, &ALightSwitchBoth::OnOverlapBegin);       // set up a notification for when this component overlaps something
    Sphere1->OnComponentEndOverlap.AddDynamic(this, &AL

OnOverlap event nodu Set Light Color noduna bağlanıyor, böylece event oluştuğumda PointLightComponent in ışık rengi random bir renge ayarlanacak. Bu, kaynak dosya içnideki PointLightComponent in görünürlüğünü (visibility) değiştiren (açık kapayan) (toggle) OnOverlap_Implementation fonksyonunu override eder.



DesiredIntensity değişkeni (variable) LightSwitchBoth in header i içinde EditAnywhere olarak ayarlanmış, dolayısı ile Blueprint Editor ünde görünüyor ve editleneiblir durumda kendileri, editlenmez ise eğer class default değeri kalacaktır. Zaten variable seçili iken details panel de görünen class default değeridir. Bunun aynı zamanda bir anlamı da class ın her bir instance in de bu değişkenin ayrı ayrı olabileceğidir; malumunuz her actor kendi ayrı DesiredIntensity değişkenine sahip oalcaktır.



Blueprint ile üretilmiş class lar da başka Blueprint class ları tarafından extend edilebilir, bu gerekse bir Blueprint class ını seçip sağ tıklayıp Create New Blueprint Based on This diyerek gerekse de Class Viewer içinden dropdown buttonu ile geçilerek de yapılabilir.




Sadece C++ :

C++ class wizard ı kullanarak kolayca projemize yeni C++ class larını ekleyebiliriz; class tipini seçtikten sonra header ve cpp kaynak dosyaları projemize otomatik olarak eklenir; eğer bu projenize eklediğiniz ilk kod ise, projeniz game modülü sizin kaynak dosyalarınızı içeren bir Code Projesine dönüştürülür; bu işlem aynı zamanda Unreal Editörünün game modülünün varlığından haberinin olmasını ve yapılmış olan C++ değişikliklerinin de Visual Studio ortamında yüklenmesine de neden olur. Minik kod değişiklikleri Unreal Editör içinde de yapılabilir.

LightSwitch sınıfını sadece C++ kullanarak yapacağımız zaman LightSwitchCodeOnly adı ile oluşturalım. 


Actor den miras alarak wizard ile LightSwitchCodeOnly class ını yaratalım; header dosyası LightSwitchCodeOnly.h oldu, ve temel class declarationunu içeriyor durumda, yani şöyle:
UCLASS()
class [PROJECTNAME]_API ALightSwitchCodeOnly : public AActor
{
GENERATED_BODY()

};
burada,
UCLASS() makrosu C++ sınıf deklerasyonundan otomatik olarak önce gelir; ve motoru bu sınıfın varlığından haberdar eder; macro yalın halde kullanılabileceği gibi çeşitli keyword specifier ler alabilir; bunlar sınıfın motor (engine) içindeki davranışına etki edecektir.

sınıf tanmlaması değişken veya fonskyon tanımı (declaration) içerebilir, bunlardan da önce UPROPERTY() ve UFUNCTION() macro belirteçleri gelir; bu arada motora ait daha büyük nesneler olan Component ler de yine UPROPERTY() macrosu ile işaretlenir.

LightSwitchCodeOnly.h header dosyamız PointLightComponent ve SphereComponent adında iki component tanımlayacaktır; bunlar VisibleAnywhere olarak işaretlenecektir; bunun anlamı Details panel içinde LightSwitchCodeOnly Actor ünün özellikleri kısmında bu component ler göünecektir.

public:
/** point light component */
UPROPERTY(VisibleAnywhere, Category = "Switch Components")
class UPointLightComponent* PointLight1;

/** sphere component */
UPROPERTY(VisibleAnywhere, Category = "Switch Components")
class USphereComponent* Sphere1;

burada yapıcı (constructor) fonksyon tanımlanıyor; böylece component ve değişkenlerin default value lerini atayabiliriz.

ALightSwitchCodeOnly();

OnOverlapBegin ve OnOverlapEnd event lerini tanımlayalım, yani bir actor SphereComponent e girdiğinde ya da çıktığında çağrılacak olan fonksyon u belirtelim; bunların farklı fonksyon imzalarına sahip olduklarını farkında olun.

/** called when something enters the sphere component */
UFUNCTION()
void OnOverlapBegin(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);

/** called when something leaves the sphere component */
UFUNCTION()
void OnOverlapEnd(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex);

şimdi ToggleLight fonksyonunu Declare edelim, PointLightComponent in visible özelliğini açıp kapayacak olan fonksyon olacak bu.

/** Toggles the light component's visibility*/
UFUNCTION()
void ToggleLight();
DesiredIntensity değişkeninin her yerde görünebilmesi için VisibleAnywhere specifier ile tanımladık; böylece Switch Variables kategorisinin Details tabı altında LightSwitchCodeOnly Actor unun özelliği olarak görünecektir.

Component ler yani subobjects olmayan değişkenler temel tiplerdir örneğin float gibi.

/** the desired intensity for the light */
UPROPERTY(VisibleAnywhere, Category="Switch Variables")
float DesiredIntensity;

header dosyasının son hali şu şekilde olacaktır:

LightSwitchCodeOnly.h

    // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.

    #pragma once

    #include "GameFramework/Actor.h"
    #include "LightSwitchCodeOnly.generated.h"

    /**
     * 
     */
    UCLASS()
    class [PROJECTNAME]_API ALightSwitchCodeOnly : public AActor
    {
        GENERATED_BODY()
        public:
        /** point light component */
        UPROPERTY(VisibleAnywhere, Category = "Switch Components")
        class UPointLightComponent* PointLight1;

        /** sphere component */
        UPROPERTY(VisibleAnywhere, Category = "Switch Components")
        class USphereComponent* Sphere1;

        ALightSwitchCodeOnly();

        /** called when something enters the sphere component */
        UFUNCTION()
        void OnOverlapBegin(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);

        /** called when something leaves the sphere component */
        UFUNCTION()
        void OnOverlapEnd(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex);

        /** Toggles the light component's visibility*/
        UFUNCTION()
        void ToggleLight();

        /** the desired intensity for the light */
        UPROPERTY(VisibleAnywhere, Category = "Switch Variables")
        float DesiredIntensity;

    };

görüleceği üzere “C++ Class Wizard” söz konusu class lar için kaynak hem header hem de cpp kaynak (source) dosyalarını da yaratıyor; yani örneğimizde kaynak dosyası LightSwitchCodeOnly.cpp oldu; ve default olarak temel içeriklere sahip olacaktır.

şimdi,

yapıcı fonksyonu ekleyelim:
    ALightSwitchCodeOnly::ALightSwitchCodeOnly()
    {

    }

C++ kodunda DesiredIntensity  değişkeninin default başlangıç değeri 3000 olarak belirleniyor;

DesiredIntensity = 3000.0f;

şimdi PointLightComponent ini yaratalım, ve alt değişkenlerini set edelim, ve onu Actor ün RootComponent i yapalım.

PointLight1 = CreateDefaultSubobject<UPointLightComponent>(TEXT("PointLight1"));
PointLight1->Intensity = DesiredIntensity;
PointLight1->bVisible = true;
RootComponent = PointLight1;

şimdi de, SphereComponent ini yaratalım, ve alt değişkenlerini PointLightComponent e Attach edelim.

Sphere1 = CreateDefaultSubobject<USphereComponent>(TEXT("Sphere1"));
Sphere1->InitSphereRadius(250.0f);
Sphere1->SetupAttachment(RootComponent);

OnOverlap işlevini, bir Aktor ona overlap olurken  veya SphereComponent'ten ayrıldığında çağırılan bir delege olarak belirleyelim;

Sphere1->OnComponentBeginOverlap.AddDynamic(this, &ALightSwitchCodeOnly::OnOverlapBegin);       // set up a notification for when this component overlaps something
Sphere1->OnComponentEndOverlap.AddDynamic(this, &ALightSwitchCodeOnly::OnOverlapEnd);       // set up a notification for when this component overlaps something

Kaynak (source) dosyanız aynı zamanda yarattığınız sınıfınız için tüm fonksyon ları tanımlayabileceğiniz yerdir. Örneğin LightSwitchCodeOnly.cpp  kaynak dosyası PointLightComponent in görünürlüğünü değiştirecek olan OnOverlapBegin  ve OnOverlapEnd implemantasyonlarına sahiptir;

constructor ile birlikte kaynak dosyamız artık şöyle görünecek:

LightSwitchCodeOnly.cpp

// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.

#include "BasicClasses.h"
#include "LightSwitchCodeOnly.h"

ALightSwitchCodeOnly::ALightSwitchCodeOnly()
{
    DesiredIntensity = 3000.0f;

    PointLight1 = CreateDefaultSubobject<UPointLightComponent>(TEXT("PointLight1"));
    PointLight1->Intensity = DesiredIntensity;
    PointLight1->bVisible = true;
    RootComponent = PointLight1;

    Sphere1 = CreateDefaultSubobject<USphereComponent>(TEXT("Sphere1"));
    Sphere1->InitSphereRadius(250.0f);
    Sphere1->SetupAttachment(RootComponent);

    Sphere1->OnComponentBeginOverlap.AddDynamic(this, &ALightSwitchCodeOnly::OnOverlapBegin);       // set up a notification for when this component overlaps something
    Sphere1->OnComponentEndOverlap.AddDynamic(this, &ALightSwitchCodeOnly::OnOverlapEnd);       // set up a notification for when this component overlaps something

}

void ALightSwitchCodeOnly::OnOverlapBegin(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
    if (OtherActor && (OtherActor != this) && OtherComp)
    {
        ToggleLight();
    }
}

void ALightSwitchCodeOnly::OnOverlapEnd(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
    if (OtherActor && (OtherActor != this) && OtherComp)
    {
        ToggleLight();
    }
}

void ALightSwitchCodeOnly::ToggleLight()
{
    PointLight1->ToggleVisibility();
}


BasicClasses.h burada ayarladığımız class ın proje adını referans ediyor;

eğer bu kodlar boş bir projeye eklediğiniz ilk kod ise önce Unreal Editörü kapamanız, Visual Studio ortamında projeyi derlemeniz ve editörü tekrar açarak yaratılan game modülünün düzgün yüklendiğine emin olmanız gerekir.

Ayrıca, Build Configuration nun projeyi açmak için kullandığınız Unreal Editör yürütülebilir dosyanın sürümüyle eşleştiğinden de emin olmanız önemlidir.

Eğer varolan bir C++ projesine kod ekliyorsanız Unreal editör içinde yeni kodu derlemek için “Hot Reload” fonksyonalitesini hızlıca kullanabilirsiniz.

son olarak,
C++ class ları başka C++ class larına base class olabileceği gibi Blueprint class larına da base class olabilir; yani Blueprint class ları onları miras alabilir (extend edebilir).


evet,
dökümantasyondaki bu mini yazının faydalı olduğunu düşündüğüm için arşive eklemek istedim. Umarım faydası dokunur.

bir başka yazıda görüşmek üzere hoşçakalın..

Hiç yorum yok: