Scene Graph’ta Dönüşümler

Bir Scene Graph varlığının dönüşümü, o varlığın yer değiştirmesini (konum), dönüşünü (yönlendirme) ve ölçeğini (boyut) tanımlar. Bir Scene Graph varlığını dönüştürmek için varlığın bir transform_component’a sahip olması gerekir. The transform_component , UEFN veya Verse kodu aracılığıyla değiştirebileceğin iki alan içerir:

• Başlangıç: LocalTransform’un hesaplanacağı isteğe bağlı bir başlangıç.

• LocalTransform: Varlığın üst öğesine veya isteğe bağlı başlangıç alanı ayarlanmışsa başlangıca göre bir (/Verse.org/SpatialMath:)transform.  

Bir varlığın başlangıcı, varlığın transform_component bileşeninin LocalTransform değerinin hesaplandığı varlıktır. Transform_component üzerindeki başlangıç alanı ayarlanmışsa bu başlangıç alanının değeri olur. Başlangıç alanı ayarlanmamışsa bu Scene Graph hiyerarşisindeki varlığın üst değeridir.

Dönüşüm ile transform_component bileşenini birbirinden ayırt etmek önemlidir. Dönüşüm, Sol-Yukarı-İleri (LUF) koordinat sisteminde aşağıdaki miktarları depolayan /Verse.org/SpatialMath modülünde tanımlı bir kompozit veri türüdür:

• Yer Değiştirme (vector3): Bir objenin konumu.

• Dönüş (dönüş): Objenin yönü.

• Ölçek (vector3): Objenin boyutu.

Transform_component, Scene Graph varlığının LocalTransform değerini ve isteğe bağlı olarak alternatif bir başlangıcını depolayan /Verse.org/SceneGraph modülünde tanımlı bir Verse sınıfıdır. Transform_component bileşenini, bir varlığa simülasyondaki yerini tanımlamak için bir dönüşüm sağlayan bir kapsayıcı olarak düşünebilirsin.

Verse Dönüşümleri 

Scene Graph, /Verse.org/SpatialMath modül dönüşümlerini kullanır. Verse modül Dönüşümleri, sağlak LUF koordinat sistemini kullanır. Bir Verse dönüşümü oluşturmak için, dönüşler oluşturmakta kullanılan sınıf arketipini ve yerleşik metotları kullanabilirsin.

# Transform specifying all fields
MyTransform:transform = transform:
	Translation := vector3{Left := 2.0, Up := -4.0, Forward := 8.0}
	Rotation := MakeRotationFromEulerDegrees(-90.0, 180.0, 0.0)
	Scale := vector3{Left := 2.0, Up := 4.0, Forward := 2.0}

# Transform specifying only Translation
MyOtherTransform:transform = transform:
	Translation := vector3{Up := 512.0}

UEFN’deki koordinat sistemi hakkında daha fazla bilgi için Sol-Yukarı-İleri Koordinat Sistemi sayfasına bak. Bu sayfa aynı zamanda /UnrealEngine.com/Temporary/SpatialMath modülü ve Verse modül dönüşümündeki XYZ dönüşümleri arasında dönüştürme hakkında bilgiler de içerir.

Transform_component ile Bir Varlık Oluştur  

UEFN anahat düzenleyicisinde veya Verse aracılığıyla bir varlık oluşturabilirsin. 

UEFN’de

Aktörleri Yerleştir menüsünü kullanarak projene hızla bir Scene Graph varlığı ekleyebilirsin.

Aktörleri Yerleştir menüsü aracılığıyla projene bir Scene Graph varlığı eklediğinde, varlık varsayılan olarak bir transform_component ile donatılır.

İstersen Anahat Düzenleyicisi paneline en son yerleştirdiğin varlığa gidip transform_component öğesini bulduktan sonra Bileşeni Kaldır kısmını seçerek transform_component öğesini kaldırabilirsin.

Söz konusu varlığın artık bir transform_component’a sahip olmadığını aşağıda görebilirsin.

Verse’te

Verse koduyla sınıf arketipine sahip bir Scene Graph varlığı oluşturduğunda:

MyEntity:entity = entity{}

Varlık bir transform_component ile donatılmaz. Bunun yerine, varlığına bir transform_component eklenmesi gerekir. Dönüşümlerle çalışmak için tercih edilen metotlar SetLocalTransform ve SetGlobalTransform’dur. Bu fonksiyonlar transform_component oluşturmayı, değerleri ayarlamayı ve varlığa dönüşüm bileşeni eklemeyi aynı anda üstlenir.

MyEntity:entity = entity{}

# Add entity to simulation entity so MyEntity begins simulating when play begins
if (SimEntity := Entity.GetSimulationEntity[]):
	SimEntity.AddEntities(array{MyEntity})

# Identity transform
IdentityTransform:transform = transform:
	Translation := vector3{Left := 0.0, Up := 0.0, Forward := 0.0}
	Rotation := MakeRotationFromEulerDegrees(0.0, 0.0, 0.0)

Bileşeni doğrudan AddComponents ile de ekleyebilirsin:

# Add entity to simulation entity so MyEntity begins simulating when play begins
if (SimEntity := Entity.GetSimulationEntity[]):
	SimEntity.AddEntities(array{MyEntity})

# Use AddComponents
MyEntity.AddComponents(array{ transform_component{ Entity := MyEntity }})

# Same as above, but more readable if adding multiple components at once
MyEntity.AddComponents of array:
    transform_component{Entity := MyEntity}

Bir Scene Graph varlığına Verse kodu aracılığıyla transform_component eklemenin diğer metotları Verse’te transform_component ile Çalışma bölümünde açıklanmaktadır.

 Bir Varlığın Dönüşümünü Hesaplama

Transform_component ile bir Scene Graph varlığı üzerinde yapabileceğin en önemli işlem, bir varlığın dönüşümünü almak veya ayarlamaktır.

İlgini çekebilecek iki tür dönüşüm vardır: Yerel dönüşüm ve global dönüşüm. Bir varlığın dönüşümünü etkili bir şekilde değiştirmek için bu dönüşümlerin nasıl hesaplandığını anlamak önemlidir.

Yerel dönüşüm, bir varlığın başlangıç noktasına göre dönüşümüdür. Herhangi bir Scene Graph varlığının yerel dönüşümü, o Scene Graph varlığının transform_component bileşeni üzerindeki LocalTransform alanının değeridir.

Global dönüşüm, global alandaki LUF koordinat sisteminin başlangıç noktasına göre dönüşümdür. Bir Scene Graph varlığının global dönüşümü, aşağıdakilerle varlığın LocalTransform değerini oluşturarak hesaplanır:

• Varlığın transform_component bileşeninde başlangıç alanı ayarlanmamışsa varlığın üst öğesinin global dönüşümü veya

• Başlangıç alanı varlığın transform_component bileşeninde ayarlanmışsa varlığın başlangıç global dönüşümü.

Aşağıda, dönüş veya ölçeklendirme olmadan yer değiştirme kullanılan bir örnek gösterilmektedir. Bu örnekte elde edilen dönüşümler, yer değiştirmeler toplanarak hesaplanabilir. Bu örnekte dönüş ve ölçeğin tüm dönüşümlerde ilgili kimliklerinde bırakıldığı varsayıldığından, varlığın dönüşümüne başvurmak için varlığın dönüşüm yer değiştirme vektörü tarafından kısaltma kullanılır.

Şu şekilde düzenlenmiş üç Scene Graph varlığını ele alalım:

• BaseEntity: LEF koordinat sisteminde LocalTransform (0,0, 0,0, 0,0).

  • A: LocalTransform (750,0, 100,0, 0,0)

    • B: LocalTransform (-250,0, 100,0, 0,0)

BaseEntity’nin mesh_component’a sahip olmadığı, A’nın küp ve B’nin de koni olduğu bir sahnedeki üç varlık aşağıda verilmiştir:

Örneğin, B varlığının hem yerel dönüşümünü hem de global dönüşümünü belirlemek istediğinizi varsayalım. Yerel dönüşüm hemen görülebilir: Aşağıda görüldüğü gibi, B varlığının transform_component bileşenine ait LocalTransform değeridir:

B varlığının yerel dönüşümü (-250,0, 100,0, 0,0).

B varlığının global dönüşümünü hesaplamak için, B varlığının hiyerarşisini simülasyon varlığına kadar geriye doğru takip edip simülasyon varlığıyla başlayarak ve B varlığına kadar dönüşümleri oluşturmalısın. Simülasyon varlığı, diğer tüm simülasyon varlıklarının üst öğesi olan geçerli simülasyonun köküdür.

B varlığının global dönüşümü bu adımlarla hesaplanır:

1. Simülasyon varlığı, mevcut simülasyonun köküdür.

   • Simülasyon varlığı global dönüşümü: (0,0, 0,0, 0,0).

2. BaseEntity, simülasyon varlığının bir alt öğesidir. Görsel 1.0’da görüldüğü gibi BaseEntity’nin yerel dönüşümü (0,0, 0,0, 0,0) şeklindedir. Simülasyon varlığının global dönüşümünü BaseEntity’nin yerel dönüşümüyle oluşturursan şu sonuçlar elde edilir:

   • BaseEntity global dönüşümü: (0,0, 0,0, 0,0) + (0,0, 0,0, 0,0) = (0,0, 0,0, 0,0).

3. A varlığı, BaseEntity’nin bir alt öğesidir. A varlığının yerel dönüşümü Görsel 1.1’de görüldüğü gibi (750,0, 100,0, 0,0) şeklindedir. BaseEntity’nin global dönüşümünü A varlığının konum dönüşümüyle oluşturursan şu sonuçlar elde edilir:

   • A varlığının global dönüşümü: (0,0, 0,0, 0,0) + (750,0, 100,0, 0,0) = (750,0, 100,0, 0,0).

4. B varlığı, A varlığının bir alt öğesidir. B varlığının yerel dönüşümü Görsel 1.2’de görüldüğü gibi (-250,0, 100,0, 0,0) şeklindedir. A varlığının nin global dönüşümünü B varlığının konum dönüşümüyle oluşturursan şu sonuçlar elde edilir:

   • B varlığının global dönüşümü: (750,0, 100,0, 0,0) + (-250,0, 100,0, 0,0) = (500,0, 200,0, 0,0).

Bu nedenle, B varlığının global dönüşümü LUF koordinat sisteminde (500,0, 200,0, 0,0) şeklinde olur.

Editörde transform_component ile Çalışma 

LocalTransform ve başlangıcı kullanarak bir varlığın dönüşümünü değiştirebilirsin. 

Yerel Dönüşüm

Bir varlığın transform_component bileşeninin LocalTransform alanı, varlığın başlangıcına göre (/Verse.org/SpatialMath:) dönüşümüdür. Başlangıç noktası alanı açıkça ayarlanmamışsa varlığın başlangıcı varsayılan durumda Scene Graph hiyerarşisindeki üst öğe olur. LocalTransform alanı, UEFN’de görünen ve bir varlığı doğrudan düzenleyebildiğin bir düzenlenebilir alandır:

1. Yer Değiştirme: Üst öğesine veya manuel olarak tanımlanmış başlangıç noktasına göre konum.

   • Bir varlığı bölüm içinde hareket ettirmek için yerini değiştirme.

2. Dönüş: Üst öğesine veya manuel olarak tanımlanmış başlangıç noktasına göre yön.

   • Bir varlığı pivot noktası etrafında döndürmek için dönüşünü değiştime.

3. Ölçek: Üst öğesine veya manuel olarak tanımlanan başlangıç noktasına göre boyut.

   • Bir varlığı büyütmek veya küçültmek için ölçeğini değiştirme.

Origin

Bir varlığın transform_component bileşeninin başlangıcı, LocalTransform’un kendisine göre hesaplanacağı objedir. Transform_component üzerindeki bu alan isteğe bağlıdır. Varsayılan olarak, transform_component bileşeninin LocalTransform değeri, sahip olan varlığın üst varlığına göre hesaplanan ve varlığın başlangıcına bağlı olan varlık dönüşümüdür. İsteğe bağlı olarak, bir varlığın transform_component bileşenindeki alanını varlığın üst öğesi dışında bir objeye göre LocalTransform’u hesaplamak için ayarlayabilirsin.

Örneğin, bir varlığın başlangıcını tamamen farklı bir varlık olarak ayarlayabilirsin. Bu alanı, Verse başlangıç arayüzünü uygulayan herhangi bir sınıfla ayarlayabilirsin. Özellikle, başlangıç alanını başka bir Scene Graph varlığı olarak ayarlamak için entity_origin sınıfını seç, ardından da yeni başlangıç olmasını istediğin varlığı seç.

Aşağıda, başlangıç alanı ve LocalTransform’un pratikte nasıl çalıştığı bir örnekle gösterilmektedir. Dünya alanının başlangıcında; küp mesh_component ile temsil edilen alt varlık A ve koni mesh_component ile temsil edilen alt varlık B ile birlikte bir BaseEntity olduğunu düşünelim.

Yukarıdaki görselde de görülebileceği gibi BaseEntity, başlangıç alanı transform_component içinde ayarlanmamış ve LocalTransform ise dünya alanının başlangıcı olarak ayarlandığından, dünya alanının başlangıcında yer alır.

Aşağıda gösterildiği gibi, A varlığının başlangıç alanının da ayarlanmamış olduğunu görebilirsin. Bu nedenle LocalTransform, üst varlığı olan BaseEntity’nin transform_component bileşenine göre hesaplanır.

BaseEntity dünya alanının başlangıç noktasında bulunduğundan ve A varlığının LocalTransform yer değiştirmesi vector3{Left := 750.0, Up := 100.0, Forward := 0.0} olarak ayarlandığından, A varlığı vector3{Left := 750.0, Up := 100.0, Forward := 0.0} konumunda yer alır. BaseEntity üzerindeki LocalTransform’un dönüşü ve ölçeği sırasıyla ilgili kimlikler olduğundan, A varlığının dönüşü ve ölçeği değişmeden kalır.

Aşağıdaki görselde, aynı zamanda BaseEntity’nin bir alt varlığı olan B varlığının, transform_component bileşeninde kendi başlangıç alanının A varlığı olarak ayarlandığını görebilirsin.

Sonuç olarak, B varlığının transform_component bileşenindeki LocalTransform alanı A varlığının hesaplanan dönüşümüne göre olur. B varlığına ait LocalTransform değeri vector3{Left := -250.0, Up := 100.0, Forward := 0.0} ve A varlığının LocalTransform değeri de vector3{Left := 750.0, Up := 100.0, Forward := 0.0} olarak ayarlandığından, B varlığının global dönüşümü vector3{Left := 500.0, Up := 200.0, Forward := 0.0} olur.

Eğer A varlığının transform_component alanının LocalTransform alanındaki dönüş bileşenini ileri eksende -90,0 derece olarak değiştirirsen B varlığı da ileri ekseninde -90,0 derece döner. Bunun nedeni, alt öğenin dönüşünü de üst öğeden devralmasıdır.

Verse’te transform_component ile Çalışma

  Bir varlığın transform_component bileşenine sahip olup olmadığını GetComponent ile kontrol edebilirsin:

MyEntityNoTransform:entity = entity{}

if (SimEntity := Entity.GetSimulationEntity[]):
	SimEntity.AddEntities(array{MyEntityNoTransform})

MyEntityWithTransform:entity = entity{}
MyEntityWithTransform.AddComponents of array:
    transform_component{Entity := MyEntityWithTransform}

if (SimEntity := Entity.GetSimulationEntity[]):

Transform_component bileşenini GetComponent kullanarak almak ve doğrudan transform_component ile çalışmak yerine, transform_component ile etkileşime geçmek için varlık genişletme metotlarının kullanılması önerilir. 

Transform

Varlığının yerel veya global dönüşümünü SetLocalTransform veya SetGlobalTransform varlık genişletme metotlarıyla doğrudan ayarlayabilirsin.

MyEntity:entity = entity{}
MyTransform:transform = transform{}

if (SimEntity := Entity.GetSimulationEntity[]):
	SimEntity.AddEntities(array{MyEntity})

# Set the local transform
MyEntity.SetLocalTransform(MyTransform)

MyOtherEntity:entity = entity{}

Bu genişletme metotları, Verse kodunda bir Scene Graph varlığı üzerinde dönüşüm ayarlamak için tercih edilir. Bu metotlar, söz konusu varlığın yerel (varlığın üst öğesine göre) veya global (dünya başlangıcına göre) dönüşümünü açıkça ayarlar. Bu fonksiyonlardan herhangi biri çağrıldığında varlığın bir transform_component’ı yoksa bir transform_component dolaylı olarak oluşturulur ve varlığa eklenir. Bu fonksiyon çağrılarının herhangi birinden sonra varlığın artık bir transform_component bileşeni olur. Bunu sonraki bir GetComponentçağrısıyla onaylayabilirsin.

if (MyEntity.GetComponent[transform_component]):
	# success, entity has a transform_component
else:
	# failure, entity does not have a transform_component

Genişletme metotlarını kullanarak, bir varlığın ilişkili transform_component bileşeninin yerel dönüşümünü veya global dönüşümünü elde edebilirsin. GetLocalTransform, bir varlığın üst varlığına veya ayarlanmışsa belirtilen başlangıç alanına göre dönüşümünü verir. Varlığın bir transform_component bileşeni yoksa bu fonksiyon kimlik dönüşümünü verir.

# Entity object
MyEntity:entity = entity{}

if (SimEntity := Entity.GetSimulationEntity[]):
	SimEntity.AddEntities(array{MyEntity})

# Obtain the local transform with respect to Parent or Origin (if set)
EntityLocalTransform := MyEntity.GetLocalTransform() # no transform component, returns identity

MyOtherEntity:entity = entity{}

GetGlobalTransform, bir varlığın dünya başlangıcına göre dönüşümünü verir. Varlığın bir transform_component bileşeni yoksa bu fonksiyon bir transform_component bileşenine sahip en yakın üst öğenin global dönüşümünü verir.

# Entity object
MyEntity:entity

if (SimEntity := Entity.GetSimulationEntity[]):
	SimEntity.AddEntities(array{MyEntity})

# Obtain the global transform
EntityGlobalTransform := MyEntity.GetGlobalTransform() # returns global transform of Simulation Entity

Origin

Varlık genişletme metotlarını, transform_component başlangıç alanını içeren işlemler için de kullanabilirsin. Varlığının transform_component öğesinin başlangıç alanını SetOrigin varlık genişletme metoduyla doğrudan ayarlayabilirsin. 

MyEntity:entity = entity{}
MyOtherEntity:entity = entity{}

if (SimEntity := Entity.GetSimulationEntity[]):
	SimEntity.AddEntities(array{MyEntity, MyOtherEntity})

MyEntity.SetLocalTransform(transform{Translation := vector3{Left := 100.0}})

# Construct an entity_origin object and set the new origin of MyEntity to MyOtherEntity
NewOrigin:entity_origin = entity_origin{Entity := MyOtherEntity}

Verse kodunda bir varlığın başlangıcını elde etmek için GetOrigin kullan.

MyEntity:entity = entity{}

if (SimEntity := Entity.GetSimulationEntity[]):
	SimEntity.AddEntities(array{MyEntity})

if (OriginValue := MyEntity.GetOrigin[]):
	# should not succeed
else:
	# should fail, no transform_component on entity MyEntity

GetOrigin, bir varlığın başlangıç alanının ayarlanmış olup olmadığına karar verir ve ayarlanmışsa o alanın değerini verir. Aksi takdirde çağrı başarısız olur. Başarılı olması durumunda ise GetOrigin fonksiyonunun dönüş türü, başlangıç arayüzünü uygulayan bir Verse sınıfı olan bir başlangıç objesidir. Bu arayüz, varlığın belirtilen başlangıcının dönüşümünü elde etmek için tek bir GetTransform fonksiyonu sağlar. Ayrıca alternatif başlangıç alanının bir varlık olarak ayarlanıp ayarlanmadığını kontrol edebilir ve hangi varlığın başlangıç olarak ayarlandığını belirleyebilirsin.

if:
	OriginValue := MyOtherEntity.GetOrigin[]		# get Origin object
	OriginEntityCast := entity_origin[OriginValue]		# cast to entity_origin
then:
	# Obtain the entity that is set as MyOtherEntity's Origin field on its transform_component
	MyOtherEntityOrigin := OriginEntityCast.Entity
	# Obtain the origin's transform
	TransformOfOrigin := OriginEntityCast.GetTransform()

Son olarak, bir varlığın transform_component bileşeninin başlangıç alanını ResetOrigin ile sıfırlayabilirsin.

MyEntity.ResetOrigin()

ResetOrigin çağrıldıktan sonra, MyEntity’nin transform_component bileşeninin başlangıç alanı sıfırlanır ve MyEntity’nin dönüşümü artık Scene Graph hiyerarşisinde MyEntity’nin üst varlığına göre hesaplanır.

Bağımlı Bileşenler

Diğer bazı Scene Graph bileşenlerinin çalışması transform_component bileşenine bağlıdır. Bunlar şunları içerir:

• Light_component ve alt sınıfları.

• Mesh_component

• Particle_system_component

Bu bileşenlerden herhangi birini transform_component bileşeni olmayan bir Scene Graph varlığına eklersen varsayılan durumda transform_component bileşeni varlığa eklenir.

XYZ Dönüşümleriyle İlgili Not

XYZ koordinat sistemini kullanan dönüşümler, /UnrealEngine.com/Temporary/SpatialMath Verse modülünde durmaya devam eder. Bu dönüşümler /Fortnite.com Verse modülündeki kreatif cihazları ve nesneler tarafından  kullanılmaya devam eder. Bu dönüşümlerin durumu ve Verse’te farklı dönüşüm türlerini birbirine dönüştürme hakkında daha fazla bilgi için Sol-Yukarı-İleri Koordinat Sistemi sayfasına bak.