ULCCComponentBase: 3DGS Bileşen Temel Sınıfı

Görüntüleme, renk, performans, çarpışma ve GIS yeteneklerini taşıyan, tüm LCC Component'lerin temel sınıfıdır. ULCCComponent (LCC1) ve ULCC2Component (LCC2) bu sınıftan türer.

#include "LCCComponentBase.h"

Örneği Actor üzerinden alın:

ULCCComponentBase* Component = LCCActor->GetLCCComponent();

Bu sayfa, her yöntemin imzasını, parametrelerini ve çağrı notlarını açıklayan bir arayüz dizinidir. Bir parametrenin nasıl ayarlanacağını ve görsel ile performans sonuçlarını öğrenmek için ilgili konu belgesine bakın:

İki İşlem Hattı Arasındaki Farklar

Bazı özellikler ve yöntemler temel sınıfta bildirilmiştir, ancak bunları yalnızca bir işlem hattı gerçekten uygular. Kod yazmadan önce hedef verinin hangi işlem hattından geçtiğini doğrulayın.

Özellikler

BlueprintSetter içeren özelliklerde, Details panelinde değeri sürüklemek ile kodda Setter çağırmak aynı yolu izler. Interp içeren özellikler Sequencer'da anahtar karelenebilir.

Yükleme Yolu

Görüntüleme Özellikleri

Performans Özellikleri

Performance alanı FRenderInfo türündedir. Her değerin bir etkinleştirme onay kutusu vardır; onay kutusu kapalıyken yerleşik varsayılan değer kullanılır. Alan listesi için Yapılar bölümüne, önerilen değerler için Performans Parametreleri bölümüne bakın.

Renk Ayarı Özellikleri

Dört bileşen sırasıyla R, G, B ve genel değere karşılık gelir. Renk ayarı efektlerinin açıklaması için Görsel Ayarlar bölümüne bakın.

Bu aralıkların yalnızca panelin kaydırıcı aralıkları (UIMin / UIMax) olduğunu ve Clamp uygulanmadığını unutmayın. Kodda bir Setter'a iletilen aralık dışı değerler kesilmez; sonuç çağıran tarafın sorumluluğundadır. Buna karşılık SplatScale ve GlobalAlpha gerçekten sınırlandırılır.

Nokta Bulutu Renklendirme Özellikleri

Çarpışma Özellikleri

Ayrıntılar için Çarpışma bölümüne bakın.

Kamera Özellikleri

Aşağıdaki üç öğe yalnızca LCC1 işlem hattında etkilidir; LCC2 bileşeninin Details paneli son iki öğeyi gizler.

GIS Özellikleri

Cesium ile birlikte kullanılan kurulum adımları için Üçüncü Taraf ve Motor Eklentisi Entegrasyonu bölümüne bakın.

Kırpma ve Kesit Özellikleri

Üç dizinin tümü BlueprintReadOnly türündedir. Öğeleri doğrudan değiştirmeyin; AddClippingVolume, AddLoadVolume ve ilgili yöntemlerle yönetin.

LoadVolumes diğer ikisinden farklı bir aşamada çalışır: veriyi yüklemeden önce filtreler ve reddedilen alanlar hiç okunmaz; kırpma hacimleri ve kesit düzlemleri ise yalnızca görüntülemeyi değiştirir. Bkz. Yükleme Hacimleri.

Animasyon Özellikleri

Animasyon iki aşamalıdır: ilk aşama FirstStageDelay kadar bekler ve ölçeği 0'dan AnimationMinScale değerine çıkarır; ikinci aşama SecondStageDelay kadar bekler ve ölçeği AnimationMinScale değerinden SplatScale değerine çıkarır.

Her parametrenin etkisi ve nasıl ayarlanacağı için Yükleme Animasyonu bölümüne bakın.

Yükleme ve Durum

Load

UFUNCTION(BlueprintCallable, Category = "XGrids")
bool Load(FString LCCPath);

Veriyi yükler. ALCCActorBase::Load sonunda bunu çağırır.

bool döndürür: yol doğrulaması geçerse ve yükleme süreci başlarsa true. Boş yol iletilirse veri kaldırılır ve yine true döndürülür.

Kullanım notları:

• true yalnızca sürecin başladığı anlamına gelir, verinin hazır olduğu anlamına gelmez. Yükleme ilerlemesini ve sonucunu izlemek için Durum Değişikliği Olayları içindeki OnLoadStateChanged / OnLoadFailed olaylarını kullanın; ayrıca meta bilginin hazır olup olmadığını CheckIfLoaded ile yoklayabilirsiniz.
• İletilen yol, şu anda yüklü olan yolla eşleşirse çağrı hemen döner ve hiçbir şey yeniden yüklenmez.
• Başarılı bir yükleme, yolu DefaultLoadPath alanına yazar.

ULCCComponentBase* Component = LCCActor->GetLCCComponent();
if (Component && Component->Load(TEXT("D:/Data/Tower/Tower.lcc")))
{
    UE_LOG(LogTemp, Log, TEXT("Load started"));
}

UnLoad

UFUNCTION(BlueprintCallable, Category = "XGrids")
virtual void UnLoad();

Veriyi kaldırır; düğüm önbelleklerini, GPU arabelleklerini ve çarpışma gövdelerini serbest bırakır ve DefaultLoadPath değerini temizler.

Dikkat edilmesi gereken iki nokta:

• DefaultLoadPath temizlendiği için UnLoad() sonrasında hemen Refresh() çağırmak hiçbir şey yüklemez.
• Meta veri temizlenmez. Kaldırmadan sonra GetMetaInfo() ve GetSplatNumber() önceki yüklemenin verisini döndürmeye devam eder; bu nedenle verinin kaldırılıp kaldırılmadığını kontrol etmek için bunları kullanmayın, CheckIfLoaded kullanın.

Refresh

UFUNCTION(BlueprintCallable, Category = "XGrids")
void Refresh();

Mevcut veriyi yeniden yükler. Uygulama UnLoad() ve Load(DefaultLoadPath) çağrılarından oluşur, dolayısıyla maliyet tam yeniden yüklemeyle aynıdır.

Diskteki veri dosyaları değiştirildikten sonra verileri diskten yeniden okumak için kullanın. Tek bir karenin görüntülemesini güncellemek için ForceUpdate kullanın.

ForceUpdate

UFUNCTION(BlueprintCallable, Category = "XGrids")
void ForceUpdate();

Bir sonraki kareyi, sahne güncellemesini bir kez zorlamak üzere işaretler; maliyeti çok düşüktür.

Eklenti, ne kamera ne de görüntüleme parametreleri değişmediği sürece düğüm güncellemelerini atlar. Görünürlüğü etkileyen bir şey dışarıdan değiştirildiğinde ve görüntü buna uymadığında, bir kare göndermek için bunu kullanın. Atlama optimizasyonunu devre dışı bırakacağı için her karede çağırmayın.

CheckIfLoaded

UFUNCTION(BlueprintPure, Category = "XGrids")
virtual bool CheckIfLoaded() const;

Meta verinin ve dizin yapısının oluşturulup oluşturulmadığı. BlueprintPure olduğundan Blueprint'te yürütme pini olmayan saf bir düğümdür.

Kesin anlamı: LCC1 düğüm yöneticisinin oluşturulup oluşturulmadığını, LCC2 ise ağacın oluşturulup oluşturulmadığını kontrol eder. true, meta veri ayrıştırmasının tamamlandığı ve meta verinin güvenle okunup parametrelerin yapılandırılabileceği anlamına gelir; ancak splat verisi görünüme göre akmaya devam eder ve görüntü dolmayı sürdürür.

Başka bir deyişle "görüntü tamamlandı" anlamına gelmez. Görüntünün kararlı hale gelmesini beklemesi gereken durumlar için bu işlev yanıt vermez.

if (Component->CheckIfLoaded())
{
    // safe to read metadata and configure parameters
}

Blueprint metin olarak, her 0,2 saniyede bir yoklama:

[Event BeginPlay]
        │
        ▼
[Set Timer by Event]
        Time = 0.2
        Looping = true
        Event ──▶ [Custom Event: CheckLoaded]

[Custom Event: CheckLoaded]
        │
        ▼
[Get LCC Component] ──▶ [Check If Loaded]
                              │ Return Value ──┐
                              ▼                │
                        [Branch] ◀─────────────┘
                              │ True
                              ▼
                        [Clear and Invalidate Timer by Handle]
                              │
                              ▼
                        (configuration after loading completes)

GetSplatNumber

UFUNCTION(BlueprintCallable, Category = "XGrids")
int GetSplatNumber() const;

Verinin toplam splat sayısını döndürür; meta verideki TotalSplats alanından alınır.

Kullanım notları:

• Bu, verinin doğal toplamıdır. Kamera hareket ettikçe değişmez ve geçerli karede gerçekten görüntülenen miktar değildir.
• İlk yüklemeden önce 0 döndürür. Ancak UnLoad() meta veriyi temizlemediği için kaldırmadan sonra da önceki değeri döndürür.
• Geçerli karenin görüntüleme yükünü öğrenmek için Actor üzerinde Stats() ile istatistik panelini açın ve canlı veriyi okuyun.

if (Component->CheckIfLoaded())
{
    UE_LOG(LogTemp, Log, TEXT("Total splats in dataset: %d"),
        Component->GetSplatNumber());
}

HaveValidSplatData

UFUNCTION(BlueprintCallable, Category = "XGrids")
virtual bool HaveValidSplatData();

Görüntüleme için geçerli splat verisi olup olmadığı. Yükleme başarısız olduğunda veya veri boş olduğunda false döndürür.

HaveValidCollisionData

UFUNCTION(BlueprintCallable, Category = "XGrids")
bool HaveValidCollisionData();

Verinin bir çarpışma dosyası içerip içermediği.

Bu işlevin yalnızca yeni collision.lci dosyasını kontrol ettiğini, eski collision.bin dosyasını ve nokta bulutu .ply çarpışmasını kontrol etmediğini unutmayın. Çarpışma yüklemesi üç biçimi de destekler; bu nedenle yalnızca collision.bin içeren bir veri kümesinde bu işlev false döndürebilirken SetLCCCollisionEnable(true) yine de başarıyla yükler.

Üç biçimi de doğru şekilde kontrol etmek için ULCCUtilLibrary::DetermineCollisionType işlevini kullanın (verileri içeren dizini iletin).

if (Component->HaveValidCollisionData())
{
    Component->SetLCCCollisionEnable(true);
}

CanRender

UFUNCTION(BlueprintCallable, Category = "XGrids")
virtual bool CanRender() const;

Görüntüleme koşullarının şu anda karşılanıp karşılanmadığını belirtir. Ölçütler, bileşenin görünürlük durumu ile alt sınıfın veri yapısının oluşturulmuş olmasıdır (LCC1 düğüm yöneticisini, LCC2 ağacı denetler). Meta veri geçerliliği bu denetime dahil değildir.

CanSetShcoef

UFUNCTION(BlueprintCallable, Category = "XGrids")
bool CanSetShcoef() const;

Verinin küresel harmonik katsayıları içerip içermediğini belirtir. Uygulama, dosya türünün EFileType::Quality olup olmadığını denetlemeye eşdeğerdir.

SetUseShcoef işlevini çağırmadan önce bunu denetleyin; ayrıca bir arayüzde küresel harmonik anahtarının devre dışı (gri) gösterilip gösterilmeyeceğine karar vermek için kullanın.

GetMetaInfo

UFUNCTION(BlueprintPure, Category = "XGrids")
virtual FMetaInfoBase GetMetaInfo() const;

Verinin meta verilerini döndürür: ad, sürüm, koordinat sistemi, toplam Level sayısı, toplam splat sayısı vb. Alanlar için Yapılar bölümüne bakın.

Yükleme tamamlandıktan sonra okuyun; veri hazır değilken alanlar sıfır değerindedir. Dönüş değeri bir temel sınıf dilimidir (slice); bu nedenle LCC1/LCC2 alanlarının tamamı için alt sınıflardaki özel yöntemleri kullanın.

if (Component->CheckIfLoaded())
{
    const FMetaInfoBase Meta = Component->GetMetaInfo();
    UE_LOG(LogTemp, Log, TEXT("Name=%s Levels=%d RTK=%s"),
        *Meta.Name, Meta.TotalLevel, Meta.IsRTK() ? TEXT("yes") : TEXT("no"));
}

GetLocalVisibleBounds

UFUNCTION(BlueprintPure, Category = "XGrids")
virtual FBox GetLocalVisibleBounds() const;

Modelin görünür sınırlayıcı kutusunu bileşen yerel uzayında döndürür. Veri kullanılamıyorsa geçersiz bir kutu (FBox(ForceInit)) döndürür; bu yüzden kullanmadan önce IsValid değerini denetleyin.

Dünya uzayı için GetComponentTransform() ile dönüştürün. Yaygın bir kullanım, tüm sahnenin görüntüye sığması için kamerayı otomatik konumlandırmaktır.

const FBox LocalBounds = Component->GetLocalVisibleBounds();
if (LocalBounds.IsValid)
{
    const FBox WorldBounds =
        LocalBounds.TransformBy(Component->GetComponentTransform());

    const FVector Center = WorldBounds.GetCenter();
    const float Radius = WorldBounds.GetExtent().Size();
    // use Center and Radius to compute the viewing position
}

GetLccVersion

virtual ELCCVersion GetLccVersion() const;

Veri sürümünü döndürür: ELCCVersion::LCC veya ELCCVersion::LCC2. Yalnızca C++.

Durum Sorgulama

Yükleme, çarpışma ve animasyon olmak üzere üç durum kategorisi için anlık sorgu arayüzleri (BlueprintPure); geçerli değeri döndürür.

UFUNCTION(BlueprintPure, Category = "XGrids")
ELCCLoadState GetLoadState() const;

UFUNCTION(BlueprintPure, Category = "XGrids")
float GetLoadProgress() const;        // 0.0 ~ 1.0

UFUNCTION(BlueprintPure, Category = "XGrids")
ELCCLoadAnimationState GetLoadAnimationState() const;

UFUNCTION(BlueprintPure, Category = "XGrids")
ELCCCollisionState GetCollisionState() const;

Değerlerin tam anlamları için Sıralamalar - Durumlar bölümüne bakın. CheckIfLoaded işlevini sürekli yoklamaya kıyasla, aşağıdaki olaylar yükleme ilerlemesini, hatayı ve çarpışma hazırlığını daha doğru gösterir.

Durum Değişikliği Olayları

Durum değiştiğinde gönderilen olaylar (BlueprintAssignable); her birinin karşılığı olan bir C++ yerel sürümü vardır (...Native, Blueprint sürümünden hemen sonra gönderilir).

// Load state change
UPROPERTY(BlueprintAssignable, Category = "XGrids|Events")
FLCCLoadStateChangedDelegate OnLoadStateChanged;             // (Component, FLCCLoadStateChange Change)

// Load failure
UPROPERTY(BlueprintAssignable, Category = "XGrids|Events")
FLCCLoadFailedDelegate OnLoadFailed;                         // (Component, FLCCLoadFailure Failure)

// Animation state change
UPROPERTY(BlueprintAssignable, Category = "XGrids|Events")
FLCCLoadAnimationStateChangedDelegate OnLoadAnimationStateChanged;   // (Component, FLCCLoadAnimationStateChange Change)

// Collision state change
UPROPERTY(BlueprintAssignable, Category = "XGrids|Events")
FLCCCollisionStateChangedDelegate OnCollisionStateChanged;  // (Component, FLCCCollisionStateChange Change)

Karşılık gelen C++ yerel olayları: OnLoadStateChangedNative, OnLoadFailedNative, OnLoadAnimationStateChangedNative, OnCollisionStateChangedNative. Olayların taşıdığı yapı alanları için Yapılar - Durumlar bölümüne bakın.

Bağlama örneği (C++):

void AMyActor::BeginPlay()
{
    Super::BeginPlay();

    if (ULCCComponentBase* Comp = LCCActor->GetLCCComponent())
    {
        Comp->OnLoadStateChangedNative.AddUObject(this, &AMyActor::HandleLoadState);
        Comp->OnLoadFailedNative.AddUObject(this, &AMyActor::HandleLoadFailed);
    }
}

void AMyActor::HandleLoadState(ULCCComponentBase* Comp, FLCCLoadStateChange Change)
{
    // Use the Change passed in; do not call GetLoadState() again here
    if (Change.NewState == ELCCLoadState::Loaded)
    {
        // The first frame of the current view is ready
    }
}

Metin Blueprint: olayları BeginPlay içinde bağlayın ve ilerlemeyi Tick içinde yoklayın:

[Event BeginPlay]
 ├─ [Bind Event to On Load State Changed]        → read Change.New State, update UI
 ├─ [Bind Event to On Load Failed]               → read Failure.Error / Message, show a prompt
 ├─ [Bind Event to On Load Animation State Changed]
 └─ [Bind Event to On Collision State Changed]

[Event Tick]
 └─ [Get Load State] == Loading ? → [Progress Bar: Set Percent] ◀ [Get Load Progress]

Kullanım kuralları (bunlara uyulmazsa sonuçlar doğru görünür ama aslında yanlıştır):

• Getter yerine geri çağrıya iletilen Change parametresini okuyun. Durum tek bir kare içinde birkaç kez değişebilir (örneğin Loaded → Unloaded → Loading → Loaded) ve Getter çoktan sonraki bir değere geçmiş olabilir.
• Olaylar, değişikliğin gerçekleştiği karenin sonunda ve BeginPlay sonrasında gönderilir. BeginPlay içinde bağlamak güvenlidir ve sahneye önceden yerleştirilmiş modellerin yükleme olayları kaçırılmaz.
• Loaded için bileşenin görüntülenmesi gerekir. Gizli bir bileşen veya LoadMode = None veri akışı yapmaz ve durum Loading olarak kalır. Yalnızca model yapısına veya çarpışmaya ihtiyaç duyan mantık, Loaded yerine Loading durumunu veya OnCollisionStateChanged olayını beklemelidir.
• Çoklu görünüm kurulumlarında Loaded, tüm görünümlerin bitmesini bekler. Bölünmüş ekran, birden çok yerel oyuncu ve birden çok editör görünüm alanı sayılır; SceneCapture sayılmaz.
• Animasyonun Finished olması, modelin ekranda tamamlandığı anlamına gelmez. Animasyon zamana göre ilerler ve verileri beklemez. Eksiksiz bir ilk kare için OnLoadStateChanged olayını kullanın.
• Blueprint geri çağrıları yalnızca PIE'de ve paketlenmiş oyunlarda tetiklenir (editör oynatma modunda değilken Blueprint'ler çalışmaz); yerel geri çağrılar editörde de tetiklenir.
• İki yükleme hatası durumunu GetLoadState ile ayırt edin: Failed = model yok; Loading / Loaded = model mevcut ancak eksik olabilir (bazı veriler okunamadı, bkz. OnLoadFailed).

Görüntüleme

Her parametrenin görsel etkisi ve ödünleşimleri için Görüntüleme ve Görsel Ayarlar bölümlerine bakın; bu bölüm yalnızca arayüzleri kapsar.

SetRenderMode / GetRenderMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetRenderMode(ERenderMode InRenderMode);

UFUNCTION(BlueprintPure, Category = "XGrids")
ERenderMode GetRenderMode() const;

3DGS (ERenderMode::Splatting) ile nokta bulutu (ERenderMode::PointCloud) arasında geçiş yapar.

Nokta bulutu modunda 3DGS'ye özgü öğelerin etkisi yoktur; opaklık bunun yerine GlobalAlpha_PointCloud değerinden gelir.

Karşılık gelen panel parametresi: Render Mode.

Component->SetRenderMode(ERenderMode::PointCloud);

Metin olarak Blueprint:

[Input Action: ToggleView]
        │ Pressed
        ▼
[Get LCC Component]
        Target = LCCActor
        │ Return Value ──┐
        ▼                │
[Set Render Mode] ◀──────┘
        Target = (Return Value)
        In Render Mode = Point Cloud

ToggleRenderMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void ToggleRenderMode();

Geçerli durumu denetlemeden 3DGS ile nokta bulutu arasında ileri geri geçiş yapar.

SetLoadMode / GetLoadMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetLoadMode(ELoadMode Mode);

UFUNCTION(BlueprintPure, Category = "XGrids")
ELoadMode GetLoadMode() const;

Ana verinin, ortam verisinin veya her ikisinin görüntülenip görüntülenmeyeceğini denetler. Değerler için ELoadMode, panel açıklaması için Load Mode bölümüne bakın.

ELoadMode::None, yüklenmiş veriler bellekte kalırken geçici gizlemeye denktir; bu nedenle geri dönüş UnLoad işlevine göre daha hızlıdır.

Component->SetLoadMode(ELoadMode::OnlyMain);

SetLightMode / GetLightMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
virtual void SetLightMode(ELightMode InLightMode);

UFUNCTION(BlueprintPure, Category = "XGrids")
ELightMode GetLightMode() const;

Verinin sahne aydınlatmasına katılıp katılmayacağını denetler: ELightMode::Unlit veya ELightMode::Lit.

İki işlem hattı bunu farklı uygular:

• LCC1 bunu Lit ve Unlit malzemeler arasında geçiş yaparak sağlar.
• LCC2 malzeme değiştirmez; aydınlatma shader içinde işlenir. Bu nedenle LCC2'de makul gölgelendirme elde etmek için ayrıca NormalMode ayarlanmalıdır, bkz. ULCC2Component ve Normaller ve Aydınlatma.

Yakalanan verilerde sahadaki aydınlatma zaten işlenmiş (baked) durumdadır; bu yüzden Lit moduna geçmek kolayca aşırı pozlamaya yol açar. LCC2, özgün parlaklığı LightingScale ile düşürebilir.

Bu Setter nokta bulutu modunda etkisizdir: atama dahili olarak atlanır ve günlüğe bir uyarı yazılır. Işık modunu değiştirmek için önce 3DGS'ye dönün.

Karşılık gelen panel parametresi: Light Mode.

ToggleLightMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void ToggleLightMode();

Unlit ile Lit arasında geçiş yapar.

SetUseShcoef / GetUseShcoef

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetUseShcoef(bool InUseShcoef);

UFUNCTION(BlueprintPure, Category = "XGrids")
bool GetUseShcoef() const;

Küresel harmonikleri açar veya kapatır. Küresel harmonikler görüş açısına bağlı renk değişimi sağlar; kapalıyken renk sabittir.

Kullanım notları:

• Verinin küresel harmonik içermesini gerektirir; bu, CanSetShcoef ile denetlenir. Portable verilerde küresel harmonik yoktur ve bu öğe panelde düzenlenemez.
• Bu Setter, nokta bulutu modunda sessizce yok sayılır. Dahili olarak verinin Quality türünde olmasını ve geçerli modun nokta bulutu olmamasını gerektirir; koşullardan biri sağlanmazsa atama atlanır.
• LCC2, bant sayısını tamamen kapatmak yerine düşürebilir; bkz. SetSHBands.
• Panel açıklaması için bkz. Küresel Harmonikler (SH).

if (Component->CanSetShcoef())
{
    Component->SetUseShcoef(false);
}

ToggleShcoef

UFUNCTION(BlueprintCallable, Category = "XGrids")
void ToggleShcoef();

Küresel harmonikleri açıp kapatır; etkiyi karşılaştırmak için kullanışlıdır.

SetSplatScale / GetSplatScale

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetSplatScale(float InSplatScale);

UFUNCTION(BlueprintPure, Category = "XGrids")
float GetSplatScale() const;

Splat dörtgen boyutu; 0,001 ile 1,0 arasındadır, varsayılan değer 1,0'dır.

Kullanım notları:

• Varsayılan değer olan 1,0 üst sınırdır, bu nedenle yalnızca düşürülebilir.
• Değeri düşürmek aşırı çizimi azaltır ve kare hızını artırır; ancak dörtgenler küçüldükçe görüntüde boşluklar oluşabilir.
• Yalnızca 3DGS modunu etkiler.
• Panel açıklaması için bkz. SplatScale.

// trade overdraw for frame rate, weighing the holes case by case
Component->SetSplatScale(0.8f);

SetGlobalAlpha / GetGlobalAlpha

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetGlobalAlpha(float InGlobalAlpha);

UFUNCTION(BlueprintPure, Category = "XGrids")
float GetGlobalAlpha() const;

3DGS genel opaklığı; 0 ile 1 arasındadır. Interp olarak işaretlidir, bu nedenle geçiş efektleri için Sequencer'da anahtar karelerle kullanılabilir.

Nokta bulutu modu için SetGlobalAlpha_PointCloud kullanın; iki değer birbirinden bağımsızdır. Panel açıklaması için bkz. Global Alpha.

// fade out frame by frame
const float Next = FMath::FInterpTo(
    Component->GetGlobalAlpha(), 0.0f, DeltaTime, 2.0f);
Component->SetGlobalAlpha(Next);

Timeline ile karartma yapan Blueprint (metin olarak):

[Timeline: FadeOut]
        Length = 2.0
        Float Track "Alpha" = 1.0 → 0.0
        │ Update
        ▼
[Set Global Alpha]
        Target = (LCC Component)
        In Global Alpha = (Alpha output of the Timeline)

SetGlobalAlpha_PointCloud / GetGlobalAlpha_PointCloud

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetGlobalAlpha_PointCloud(float InGlobalAlpha);

UFUNCTION(BlueprintPure, Category = "XGrids")
float GetGlobalAlpha_PointCloud() const;

Nokta bulutu modundaki genel opaklık; 0 ile 1 arasındadır, varsayılan değer 0,2'dir.

SetUseMipFilter / GetUseMipFilter

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetUseMipFilter(bool InUseMipFilter);

UFUNCTION(BlueprintPure, Category = "XGrids")
bool GetUseMipFilter() const;

Titreme önleme filtresini açıp kapatır; varsayılan olarak etkindir. Etkin olduğunda opaklık telafili bir alçak geçiren filtre kullanır ve farklı ölçeklerde daha kararlıdır; devre dışı olduğunda görüntü daha keskindir ancak tırtıklanma ve titreme oluşabilir. Yalnızca 3DGS modunda etkilidir.

Panel açıklaması için bkz. Mip Filter.

EnableReceiveShadows / DisableReceiveShadows

UFUNCTION(BlueprintCallable, Category = "XGrids")
void EnableReceiveShadows();

UFUNCTION(BlueprintCallable, Category = "XGrids")
void DisableReceiveShadows();

Gölge almayı açıp kapatır; deneysel bir özelliktir.

Kullanım notları:

• Yalnızca LCC1 işlem hattında desteklenir; LCC2 bileşeninin Details panelinde bu özellik gizlenir.
• Yalnızca 3DGS modunda etkilidir ve performansı önemli ölçüde etkiler.
• Dahili olarak özel bir malzemeye geçilerek uygulanır, bu nedenle malzeme kurulumu yeniden çalışır.
• Panel açıklaması için bkz. Shadow Receiving.

Performans

Bu Setter grubu tek bir davranışı paylaşır: herhangi birini çağırmak, ilgili etkinleştirme onay kutusunu otomatik olarak true yapar. Getter'lar etkin değeri döndürür; onay kutusu kapalıyken daha önce girilen değeri değil, yerleşik varsayılan değeri döndürür.

GetPreloadDistance tek istisnadır: etkin değeri değil, ham alan değerini döndürür.

Önerilen değerler için bkz. Performans Parametreleri ve Performans Kılavuzu.

SetMaxDistance / GetMaxDistance

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetMaxDistance(const int32 InDistance);

UFUNCTION(BlueprintPure, Category = "XGrids")
int32 GetMaxDistance() const;

Metre cinsinden en büyük görüntüleme mesafesi; yerleşik varsayılan değer 300'dür. Bu mesafenin ötesindeki düğümler görüntülenmez.

İlgili panel parametresi: Max Distance.

Component->SetMaxDistance(80);

SetMaxSplatNum / GetMaxSplatNum

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetMaxSplatNum(const int32 InSplatNum);

UFUNCTION(BlueprintPure, Category = "XGrids")
int32 GetMaxSplatNum() const;

Kare başına en büyük splat sayısı; on bin birimi cinsindendir, üst sınır 10000'dir. 1500 girilmesi 15 milyon anlamına gelir.

GPU'nun tek karede işleyebileceği değeri aşan değerler otomatik olarak sınırlandırılır. İlgili panel parametresi: Max Splat Num.

Component->SetMaxSplatNum(1500);   // 15 million

SetLevelFactor / GetLevelFactor

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetLevelFactor(const float InLevelFactor);

UFUNCTION(BlueprintPure, Category = "XGrids")
float GetLevelFactor() const;

LOD ölçek çarpanı; 0,01 ile 20 arasındadır, varsayılan değer 1'dir. Daha büyük değer, daha az ayrıntı ve daha iyi performans anlamına gelir.

Mekanizma, işlem hattına göre farklılık gösterir:

• LCC1: proje ayarlarındaki RangeForLevel değerini ölçekler ve mesafe ile Level arasındaki eşlemeyi değiştirir.
• LCC2: düğüm seçimi sırasında ekran uzayı hatasının ölçek çarpanı olarak çalışır.

Bu nedenle aynı değerin görsel etkisi iki işlem hattı arasında doğrudan karşılaştırılamaz; her birini ayrı ayrı ölçün.

İlgili panel parametresi: Level Factor.

Component->SetLevelFactor(1.5f);

SetStartLevel / GetStartLevel

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetStartLevel(const int32 InStartLevel);

UFUNCTION(BlueprintPure, Category = "XGrids")
int32 GetStartLevel() const;

Start Level; 0 ile 20 arasındadır, varsayılan değer 0'dır. Level 0 en yüksek ayrıntıya sahiptir; değeri artırmak en ince seviyeleri atlar ve video belleği kullanımını ile yükleme miktarını belirgin biçimde azaltır.

İlgili panel parametresi: Start Level.

SetEndLevel / GetEndLevel

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetEndLevel(const int32 InEndLevel);

UFUNCTION(BlueprintPure, Category = "XGrids")
int32 GetEndLevel() const;

End Level; 0 ile 20 arasındadır, varsayılan değer 20'dir. En kaba Level'ı sınırlar ve normalde değiştirilmesi gerekmez.

İlgili panel parametresi: End Level.

SetMaxCollisionDistance / GetMaxCollisionDistance

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetMaxCollisionDistance(const int32 InMaxCollisionDistance);

UFUNCTION(BlueprintPure, Category = "XGrids")
int32 GetMaxCollisionDistance() const;

Metre cinsinden en büyük çarpışma yükleme mesafesi; yerleşik varsayılan değer 300'dür.

Uzun menzilli ışın testlerinde bu değerin test aralığını kapsaması gerekir, aksi takdirde hiçbir şeye isabet edilmez.

İlgili panel parametresi: Max Load Collision Distance.

SetPreloadDistance / GetPreloadDistance

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetPreloadDistance(const int32 InPreloadDistance);

UFUNCTION(BlueprintPure, Category = "XGrids")
int32 GetPreloadDistance() const;

Metre cinsinden ön yükleme mesafesi.

Not: Geçerli sürümde etkin mantık MaxDistance + 35 olarak sabittir; Setter ile ayarlanan değer hesaplamaya katılmaz ve bu öğe panelde gösterilmez. Arayüz uyumluluk için korunmuştur ve normal kullanımda çağrılmasına gerek yoktur.

Renk Ayarı

Renk ayarı özelliklerinin tümü FVector4 türündedir; dört bileşen sırasıyla R, G, B ve genel değere karşılık gelir. Tüm renk ayarı Setter'ları anında etkili olur. Etkilerin açıklaması için bkz. Görsel Ayarlar.

UFUNCTION(BlueprintCallable, Category = "XGrids|Color")
void SetSaturation(const FVector4 InSaturation);   // saturation, 0~2
void SetContrast(const FVector4 InContrast);       // contrast, 0~2
void SetGamma(const FVector4 InGamma);             // gamma, 0~2
void SetOffset(const FVector4 InOffset);           // additive offset, -1~1
void SetColorTint(const FLinearColor InColor);     // multiplicative tint

// matching Getters
FVector4 GetSaturation() const;
FVector4 GetContrast() const;
FVector4 GetGamma() const;
FVector4 GetOffset() const;
FLinearColor GetColorTint() const;

Offset toplamsaldır ve koyu alanları diğer her şeyle birlikte yükseltir; ColorTint çarpımsaldır ve koyu alanları koyu tutar. Her öğenin etkisi için bkz. Renk Ayarı.

// lower saturation and brighten slightly
Component->SetSaturation(FVector4(0.6f, 0.6f, 0.6f, 0.6f));
Component->SetOffset(FVector4(0.05f, 0.05f, 0.05f, 0.f));

Nokta Bulutu Yükseklik Renklendirmesi

UFUNCTION(BlueprintCallable, Category = "XGrids|PointCloud")
void SetElevationColorBottom(FLinearColor InElevationColorBottom);

UFUNCTION(BlueprintCallable, Category = "XGrids|PointCloud")
void SetElevationColorTop(FLinearColor InElevationColorTop);

UFUNCTION(BlueprintPure, Category = "XGrids|PointCloud")
FLinearColor GetElevationColorBottom() const;

UFUNCTION(BlueprintPure, Category = "XGrids|PointCloud")
FLinearColor GetElevationColorTop() const;

Yükseklik gradyanının alt ve üst renkleri; varsayılan olarak maviden kırmızıya.

Component->SetRenderMode(ERenderMode::PointCloud);
Component->SetElevationColorBottom(FLinearColor(0.0f, 0.2f, 1.0f, 1.0f));
Component->SetElevationColorTop(FLinearColor(1.0f, 0.1f, 0.0f, 1.0f));

Çarpışma

SetLCCCollisionEnable

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetLCCCollisionEnable(const bool InEnable);

Çarpışma verisi yüklemeyi açıp kapatır.

Kullanım notları:

• Verinin bir çarpışma dosyası içermesi gerekir; önce HaveValidCollisionData ile doğrulayın.
• Çarpışma verisi mesafeye göre aktarılır ve Performance.CollisionLoadMaxDistance ile sınırlanır.
• Etkinleştirildikten sonra LineTraceByChannel, karakter hareketi ve fizik simülasyonu gibi motor özellikleri doğrudan çalışır.
• İlk etkinleştirme, kısa süreli takılmaya neden olabilecek tek seferlik bir hazırlama maliyeti içerir. Mümkünse yükleme aşamasında etkinleştirin.
• Actor üzerindeki ShowCollision(), çarpışmanın yüklenip yüklenmediğini doğrulamak için çarpışma tel kafesini gösterir.

Tam açıklama için bkz. Çarpışma.

if (Component->HaveValidCollisionData())
{
    Component->SetMaxCollisionDistance(50);
    Component->SetLCCCollisionEnable(true);
}

GIS

Coğrafi yerleşim genellikle bir LCC sahnesini gerçek dünya koordinatlarına yerleştirmek için Cesium ile birlikte kullanılır. Kurulum adımları, eklenti bağımlılıkları ve dikkat edilecek noktalar için bkz. Üçüncü Taraf ve Motor Eklentisi Entegrasyonu.

SetGeoPlacement

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetGeoPlacement(bool InEnable);

Sahnenin enlem ve boylama göre yerleştirilmesini açıp kapatır.

Etkinleştirildiğinde sahne gerçek coğrafi koordinatlara göre otomatik konumlandırılır, elle ayarlanan Actor konumunun üzerine yazılır ve ince ayar GeoLocationOffset üzerinden yapılır. Etkinleştirilmiş birden çok LCC sahnesi, gerçek göreli konumlarında otomatik olarak hizalanır.

Kullanım notları:

• Dahili olarak bir Refresh() çalışır (kaldırma ve yeniden yükleme), bu nedenle çağrı her zaman etkili olur ve elle Load() çağırmaya gerek yoktur. Maliyeti tam yeniden yüklemeyle aynıdır, bu yüzden sık sık açıp kapatmayın.
• Verinin RTK bilgisi içermesi gerekir. CanUseGeoPlace() ile değil, GetMetaInfo().IsRTK() ile kontrol edin: İkincisi, coğrafi yerleşimin zaten etkin olmasını gerektirir ve bundan önce her zaman false döndürür.

if (Component->CheckIfLoaded() && Component->GetMetaInfo().IsRTK())
{
    Component->SetGeoPlacement(true);   // reloads automatically
}

CanUseGeoPlace

UFUNCTION(BlueprintCallable, Category = "XGrids")
bool CanUseGeoPlace() const;

Coğrafi yerleştirmenin şu anda kullanılabilir durumda olup olmadığını belirtir. Üç koşulun aynı anda sağlanması gerekir: bEnableGeoPlace etkin olmalı, veri RTK bilgisi taşımalı ve jeoreferanslama sistemi oluşturulmuş olmalıdır.

Bu, "verinin coğrafi yerleştirmeyi destekleyip desteklemediği" için bir ölçüt değildir. bEnableGeoPlace değerinin zaten true olmasını gerektirdiği için, etkinleştirmeden önce yapılan çağrı her zaman false döndürür. Etkinleştirmeden önce verinin bunu destekleyip desteklemediğini denetlemek için GetMetaInfo().IsRTK() kullanın.

Asıl amacı, etkinleştirmeden sonra ayarın gerçekten devreye girdiğini doğrulamaktır.

GetRTKBaseLocation

UFUNCTION(BlueprintCallable, Category = "XGrids")
FVector GetRTKBaseLocation() const;

Verinin coğrafi başlangıç noktası olan RTK baz istasyonu konumunu motor uzayına dönüştürerek döndürür. Harici coğrafi koordinatların motor koordinatlarına dönüştürülmesi gerektiğinde referans noktasıdır.

Not: Koordinat dönüşümü için dahili olarak jeoreferanslama sistemini null denetimi yapmadan doğrudan kullanır. Jeoreferanslama sistemi oluşturulmamışken çağrıldığında çökme meydana gelir. Çağırmadan önce CanUseGeoPlace değerinin true olduğunu ya da GetGeoReferencingSystem çağrısının null olmayan bir değer döndürdüğünü doğrulayın.

GetGeoReferencingSystem

UFUNCTION(BlueprintCallable, Category = "XGrids")
ALCCGeoReferencingSystem* GetGeoReferencingSystem() const;

Sahnedeki jeoreferanslama sistemi Actor'ünü döndürür. Bu Actor, coğrafi yerleştirme etkinleştirildiğinde eklenti tarafından otomatik olarak oluşturulur.

ALCCGeoReferencingSystem* GeoSystem = Component->GetGeoReferencingSystem();
if (GeoSystem)
{
    // projected coordinates to engine coordinates
    FVector EngineLocation;
    GeoSystem->ProjectedToEngine(ProjectedCoord, EngineLocation);

    // east/north/up directions at that point
    FVector East, North, Up;
    GeoSystem->GetENUVectorsAtEngineLocation(EngineLocation, East, North, Up);
}

Çoklu Görüntü Alanı

Aynı veri seti, farklı kameralar için farklı görüntüleme stratejileri kullanabilir. Tipik kullanım, ana görüntü alanında yüksek kaliteli 3DGS, mini harita için ise SceneCapture üzerinden görüntülenen kuşbakışı nokta bulutu görünümüdür.

Not: Bu arayüz grubu hem LCC1 hem de LCC2 işlem hatları tarafından desteklenir. Her ikisi de kendi görüntüleme yollarında görüntü alanı başına stratejiyi kullanır. Tamsayı kimlikleri değil, nesne işaretçileri alırlar.

Bu sayfada yalnızca arayüz imzaları ve çağrı noktaları listelenir. Kullanım senaryolarının tamamı, bölünmüş ekran ve SceneCapture adımları ile çağrı zamanlaması gibi sık yapılan hatalar için En İyi Uygulamalar - Kamera Başına Bağımsız Görüntüleme bölümüne bakın.

Birden fazla kamera ve birden fazla ekran çıkışına (nDisplay, Aximmetry, Pixotope ve diğerleri) ilişkin genel yaklaşım için Üçüncü Taraf ve Motor Eklentisi Entegrasyonu bölümüne bakın.

SetPlayerLoadMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetPlayerLoadMode(class APlayerController* PlayerController, ELoadMode InLoadMode);

Belirtilen oyuncu denetleyicisi için ayrı bir LoadMode ayarlar ve bir sonraki karede etkili olur.

APlayerController* PC2 = UGameplayStatics::GetPlayerController(GetWorld(), 1);
Component->SetPlayerLoadMode(PC2, ELoadMode::OnlyMain);

SetPlayerRenderMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetPlayerRenderMode(class APlayerController* PlayerController, ERenderMode InRenderMode);

Belirtilen oyuncu denetleyicisi için ayrı bir RenderMode ayarlar ve bir sonraki karede etkili olur.

SetSceneCaptureLoadMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetSceneCaptureLoadMode(class USceneCaptureComponent2D* InCapture2D, ELoadMode InLoadMode);

Belirtilen SceneCapture için ayrı bir LoadMode ayarlar.

Önce proje ayarlarında SceneCaptureComponent Support seçeneği etkinleştirilmelidir; aksi halde LCC içeriği SceneCapture içinde görüntülenmez.

SetSceneCaptureRenderMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetSceneCaptureRenderMode(class USceneCaptureComponent2D* InCapture2D, ERenderMode InRenderMode);

Belirtilen SceneCapture için ayrı bir RenderMode ayarlar.

// minimap uses point cloud and the main part only, the cheapest option
Component->SetSceneCaptureRenderMode(MinimapCapture, ERenderMode::PointCloud);
Component->SetSceneCaptureLoadMode(MinimapCapture, ELoadMode::OnlyMain);

ModifyPlayerTransform

UFUNCTION(BlueprintCallable, Category = "XGrids")
void ModifyPlayerTransform(class APlayerController* PlayerController, FTransform InTransform);

Belirtilen oyuncunun bu sahnedeki konumunu geçersiz kılar. Işınlanmadan önce hedefin verilerini önceden yüklemek için kullanılır.

Çözdüğü sorun: uzak bir yere doğrudan ışınlanmak hedef düğümlerini yüklenmemiş bırakır; oyuncu boş bir ana bölüm görür ve bu bölüm kademeli olarak dolar.

Doğru sıra:

ModifyPlayerTransform(destination)
        ↓ wait around 0.2 seconds so the destination nodes start loading
teleport the player for real
        ↓ wait around another 0.2 seconds
CancelModifyPlayerTransform

void AMyTeleporter::TeleportWithPreload(APlayerController* PC, const FTransform& Destination)
{
    Component->ModifyPlayerTransform(PC, Destination);

    FTimerHandle Handle;
    GetWorld()->GetTimerManager().SetTimer(Handle,
        [this, PC, Destination]()
        {
            PC->GetPawn()->SetActorTransform(Destination);

            FTimerHandle CancelHandle;
            GetWorld()->GetTimerManager().SetTimer(CancelHandle,
                [this, PC]()
                {
                    Component->CancelModifyPlayerTransform(PC);
                },
                0.2f, false);
        },
        0.2f, false);
}

Metin olarak Blueprint:

[Custom Event: TeleportTo]
        Destination (Transform)
        │
        ▼
[Modify Player Transform]
        Target = (LCC Component)
        Player Controller = Get Player Controller
        In Transform = Destination
        │
        ▼
[Delay]  Duration = 0.2
        │
        ▼
[Set Actor Transform]
        Target = Get Player Pawn
        New Transform = Destination
        │
        ▼
[Delay]  Duration = 0.2
        │
        ▼
[Cancel Modify Player Transform]
        Target = (LCC Component)
        Player Controller = Get Player Controller

CancelModifyPlayerTransform

UFUNCTION(BlueprintCallable, Category = "XGrids")
void CancelModifyPlayerTransform(class APlayerController* PlayerController);

Konum geçersiz kılmasını iptal eder ve anlık oyuncu konumunun kullanımına geri döner.

Çağrılması gerekir; aksi halde o oyuncu için düğüm zamanlaması geçersiz kılınan konumda takılı kalır ve oyuncu hareket ettikçe yeni düğümler yüklenmez.

Kırpma ve Kesit

Kırpma ve kesit kullanımı için ALCCClippingVolume ve ALCCSectionPlane ile birlikte Sahne Düzenleme bölümüne bakın.

AddClippingVolume

UFUNCTION(BlueprintCallable, Category = "XGrids")
void AddClippingVolume(ALCCClippingVolume* InClippingVolume);

Bir kırpma hacmi ekler.

ALCCClippingVolume* Volume = GetWorld()->SpawnActor<ALCCClippingVolume>(
    ALCCClippingVolume::StaticClass(), Location, FRotator::ZeroRotator);

Volume->VolumeType = EClipVolumeType::Box;
Volume->Mode = EClipType::Inside;
Volume->bEnabled = true;

Component->AddClippingVolume(Volume);

RemoveClippingVolume

UFUNCTION(BlueprintCallable, Category = "XGrids")
void RemoveClippingVolume(ALCCClippingVolume* InClippingVolume);

Bir kırpma hacmini kaldırır. Geçici devre dışı bırakma için kırpma hacmindeki bEnabled değerini değiştirmek daha hafiftir.

AddSectionPlane

UFUNCTION(BlueprintCallable, Category = "XGrids")
void AddSectionPlane(ALCCSectionPlane* InSectionPlane);

Bir kesit düzlemi ekler.

RemoveSectionPlane

UFUNCTION(BlueprintCallable, Category = "XGrids")
void RemoveSectionPlane(ALCCSectionPlane* InSectionPlane);

Bir kesit düzlemini kaldırır.

AddLoadVolume

UFUNCTION(BlueprintCallable, Category = "XGrids")
void AddLoadVolume(ALCCLoadVolume* InLoadVolume);

Yüklenecek veriyi bölgeye göre filtreleyen bir yükleme hacmi ekler.

ALCCLoadVolume* Volume = GetWorld()->SpawnActor<ALCCLoadVolume>(
    ALCCLoadVolume::StaticClass(), Location, FRotator::ZeroRotator);

Volume->VolumeType = ELoadVolumeType::Box;
Volume->Mode = ELoadRegion::Inside;
Volume->bEnabled = true;

Component->AddLoadVolume(Volume);
Component->Load(Path);   // filtering happens at load time, so configure it first

Filtreleme yükleme sırasında gerçekleşir; bu nedenle Load öncesinde yapılandırılmalıdır. Yükleme tamamlandıktan sonra bir yükleme hacmi eklemek veya kaldırmak, etkili olması için yeniden yükleme gerektirir.

Pro sürüm özelliğidir; lisans olmadan etkisi yoktur ve veri tüm kapsamıyla yüklenir.

RemoveLoadVolume

UFUNCTION(BlueprintCallable, Category = "XGrids")
void RemoveLoadVolume(ALCCLoadVolume* InLoadVolume);

Bir yükleme hacmini kaldırır. Halihazırda yüklenmiş verinin kapsamını değiştirmek için de yeniden yükleme gerekir.

Yükleme Animasyonu

SetEnableAnimation / GetEnableAnimation

UFUNCTION(BlueprintCallable, Category = "XGrids|Animation")
void SetEnableAnimation(bool bInEnableAnimation);

UFUNCTION(BlueprintPure, Category = "XGrids|Animation")
bool GetEnableAnimation() const;

Animasyonu açar veya kapatır ve animasyon zamanlayıcısının başlangıcını geçerli zamana sıfırlar. Bu nedenle yalnızca yükleme aşamasıyla sınırlı değildir: herhangi bir anda yapılan çağrı animasyonu baştan oynatır.

Her aşamanın parametreleri doğrudan özelliklerde ayarlanır; ayrı Setter'lar yoktur. Parametrelerin animasyonun tamamına uygulanması için bu işlevi çağırmadan önce ayarlayın. Oynatma sırasında bir parametreyi değiştirmek de etkili olur ve animasyon sırasında yapılan bir ayar işlevi görür.

Component->AnimationSpeed = 30.0f;
Component->SecondStageDelay = 1.0f;
Component->SetEnableAnimation(true);

Ters (kaybolma) animasyonu, çağrı sırası, parametre değerleri ve pratik notlar için Yükleme Animasyonu bölümüne bakın.

Ayrıca Bakın

• ALCCActorBase: Actor tarafı arayüzleri
• ULCCComponent: yalnızca LCC1 için nokta bulutu ışın testi
• ULCC2Component: yalnızca LCC2 için küresel harmonikler ve normal modları
• Enum'lar: ERenderMode, ELoadMode, ELightMode ve diğerlerinin değerleri
• Struct'lar: FRenderInfo ve FMetaInfoBase alanları