Gerçek Zamanlı Aydınlatma Geliştirme Kılavuzu

LCC Unity SDK, dinamik nokta ışıklarından ve spot ışıklarından gelen gerçek zamanlı aydınlatmayı destekler. Aşağıda, dairesel bir yol boyunca hareket eden bir nokta ışığı örneğiyle gerçek zamanlı aydınlatmanın uygulanma adımları baştan sona anlatılmaktadır.

Adım 1: Sahneyi ve GameObject'leri Oluşturma

Unity'de yepyeni bir sahne oluşturun. Unity varsayılan olarak Main Camera ve Directional Light oluşturur.

Main Camera Ayarlama

Hierarchy penceresinde Main Camera nesnesini seçin ve özelliklerini Inspector penceresinde aşağıda gösterildiği gibi ayarlayın.

Main Camera özelliklerini ayarlama

LCCManager Oluşturma

Hierarchy penceresinde boş bir alana sağ tıklayın, açılan menüden Create Empty seçeneğini seçerek boş bir GameObject oluşturun, adını LCCManager yapın, Transform değerini normalleştirin ve Add Component ile bu nesneye LCCManager betiğini ekleyin.

LCCManager GameObject'ini oluşturun ve LCCManager betiğini ekleyin

LCCRenderer Oluşturma

Hierarchy penceresinde boş bir alana sağ tıklayın, Create Empty seçeneğini seçerek boş bir GameObject oluşturun, adını LCCRenderer yapın ve Transform değerlerini Rotation.x = -90 ve Scale.x = -1 olarak ayarlayın.

LCCRenderer oluşturma ve Transform ayarı (Rotation.x = -90, Scale.x = -1)

Not:

LCCRenderer GameObject'inin Transform ayarları (Rotation.x = -90, Scale.x = -1) onu LCC veri koordinat sistemiyle hizalar. Koordinat sistemi hizalaması hakkında ayrıntılar için Unity SDK'ya Giriş belgesindeki "LCC Veri Koordinat Sistemi" bölümüne bakın.

2. Adım: Işıkları Gönderecek Bir Betik Yazın

Relighting.cs adında yeni bir C# betiği oluşturun ve aşağıdaki kodu ekleyin:

using System.Collections.Generic;
using LCCCore;
using Unity.Mathematics;
using UnityEngine;

public class Relighting : MonoBehaviour
{
    public LCCManager m_manager;
    public string m_FilePath;
    private LCCCore.Renderer m_renderer;

    [Header("Point Light Settings")]
    public Vector3 pointLightPosition = new Vector3(0, 2, 0);
    public Color pointLightColor = Color.red;
    public float pointLightIntensity = 2.0f;
    public float pointLightRange = 3.0f;

    [Header("Spot Light Settings")]
    public Vector3 spotLightPosition = new Vector3(0, 2, -2);
    public Vector3 spotLightDirection = new Vector3(0, -1, 0);
    public Color spotLightColor = new Color(0.1f, 0.9f, 0.7f);
    public float spotLightIntensity = 3.0f;
    public float spotLightRange = 20.0f;
    public float spotLightAngle = 45.0f;

    [Header("Animation")]
    public bool animateLights = true;
    public float rotateSpeed = 30.0f;

    private List<PointLightData> m_lights = new List<PointLightData>();
    private float m_angle;

    void Start()
    {
        m_manager.SetPlatformType(PlatformType.PC);
        m_manager.SwitchRenderPass(ActiveRenderMode.SingleRender);
        m_manager.SetMainCamera(Camera.main);

        m_renderer = m_manager.GetRender(this.transform);
        m_renderer.Load(m_FilePath, onProgress, onComplete);
    }

    private void onProgress(float _progress)
    {
        Debug.Log($"[Relighting] load progress: {_progress:P1}");
    }

    private void onComplete()
    {
        Debug.Log("[Relighting] load complete, setting up lights");
        //m_manager.SetLightIntensity(0.5f);
        ApplyLights();
    }

    void Update()
    {
        if (!animateLights) return;

        m_angle += rotateSpeed * Time.deltaTime;
        ApplyLights();
    }

    private void ApplyLights()
    {
        m_lights.Clear();

        float rad = m_angle * Mathf.Deg2Rad;
        float px = pointLightPosition.x + Mathf.Cos(rad) * 3f;
        float pz = pointLightPosition.z + Mathf.Sin(rad) * 3f;

        // lightType 0 = point light
        m_lights.Add(new PointLightData
        {
            position = new float3(px, pointLightPosition.y, pz),
            lightType = 0,
            color = new float3(pointLightColor.r, pointLightColor.g, pointLightColor.b),
            intensity = pointLightIntensity,
            direction = float3.zero,
            range = pointLightRange,
            spotAngle = 0f,
            pad = float3.zero
        });

        // lightType 1 = spotlight
        Vector3 dir = spotLightDirection.normalized;
        m_lights.Add(new PointLightData
        {
            position = new float3(spotLightPosition.x, spotLightPosition.y, spotLightPosition.z),
            lightType = 1,
            color = new float3(spotLightColor.r, spotLightColor.g, spotLightColor.b),
            intensity = spotLightIntensity,
            direction = new float3(dir.x, dir.y, dir.z),
            range = spotLightRange,
            spotAngle = spotLightAngle,
            pad = float3.zero
        });

        int result = m_manager.SetLights(m_lights);
        if (result != 0)
            Debug.LogWarning($"[Relighting] SetLights failed: {result}");
    }

    void OnDisable()
    {
        // Pass null to disable custom lighting
        m_manager.SetLights(null);
    }
}

Not:

• Gerçek zamanlı aydınlatma, LCC sahnesinin yüklenmesi tamamlandıktan sonra gönderilmelidir. Bu nedenle ilk ApplyLights() çağrısı onComplete geri çağrısında yapılır.
• Bu örnek, nokta ışığının dairesel bir yol boyunca hareketini canlandırmak için ışık konumunu Update içinde her karede yeniler.
• Işık alanı türü Unity.Mathematics.float3 olup using Unity.Mathematics; gerektirir. color yalnızca üç RGB bileşeni içerir, alfa içermez.

3. Adım: Betiği Ekleyin ve Veri Yolunu Ayarlayın

1. Relighting.cs betiğini Hierarchy penceresindeki LCCManager GameObject'ine ekleyin.
2. Inspector penceresinde LCCManager GameObject'ini betiğin Manager özelliğine sürükleyin.
3. Betiğin File Path özelliğine LCC dosya yolunu girin.
4. Diğer nokta ışığı, spot ışığı ve animasyon özellikleri istediğiniz gibi yapılandırılabilir.

Relighting betiğini ekleyin ve özelliklerini Inspector'da ayarlayın

Bu örnekte bir nokta ışığı ve bir spot ışığı oluşturulur; gerçek zamanlı aydınlatma etkisini göstermek için nokta ışığı dairesel bir yol boyunca hareket eder.

Adım 4: Çalıştırma

Sahnedeki gerçek zamanlı aydınlatma etkisini görmek için Game penceresinde Play düğmesine tıklayın.

Çalıştırıldıktan sonra 3DGS sahnesindeki gerçek zamanlı aydınlatma etkisi

3DGS Aydınlatmasının Özellikleri

3DGS'de aydınlatma, geleneksel Mesh modellerdeki aydınlatmadan büyük ölçüde farklıdır. 3DGS'de aydınlatma etkisi doğrudan RGB rengine yazılır; yani aydınlatma, görüntülenen renk bileşenlerine işlenmiş olur. Bu nedenle bir 3DGS modeli güneşli bir günde, çok sert gölgelerle taranmışsa, yeniden aydınlatma bu önceden işlenmiş gölgeleri ortadan kaldıramaz.

Ayrıca görüntüleme sırasında renk aralığı [0, 1] değerindedir. Aydınlatmayı herhangi bir işlem yapmadan doğrudan güçlendirirseniz aşırı pozlama oluşur. Aşırı pozlamayı önlemek için genellikle yeniden aydınlatmadan önce 3DGS sahnesi karartılır.

SDK'da aydınlatma yoğunluğu LCCManager.SetLightIntensity(float _intensity) ile ayarlanabilir:

• _intensity giriş parametresi [0, 1] aralığındadır.
• Bu işlev genel aydınlatma etkisini değiştirir: Ayarlanan ışık yoğunluğu arttıkça 3DGS sahnesi daha fazla kararır.
• Varsayılan değer 0.5 şeklindedir.

İpucu:

Aydınlatma hesaplaması nispeten maliyetli bir işlemdir. SDK, en fazla 50 dinamik ışığı (nokta ışıkları ve spot ışıkları toplamı) destekler. Sınır aşıldığında SetLights işlevi -1 döndürür ve etkili olmaz.

Temel Adımlar

3DGS sahnesine gerçek zamanlı aydınlatma eklemenin temel adımları:

1. SetPlatformType / SwitchRenderPass / SetMainCamera ön yapılandırmasını tamamlayın ve LCC sahnesini GetRender + Load ile yükleyin.
2. Sahne yüklemesi tamamlandıktan sonra (onComplete geri çağrısında) PointLightData listesini oluşturun ve ışıkları göndermek için SetLights işlevini çağırın.
3. Animasyon gerekiyorsa ışık parametrelerini Update içinde güncelleyin ve SetLights işlevini yeniden çağırın.
4. Aşırı pozlama oluşursa yeniden aydınlatmadan önce SetLightIntensity ile sahneyi karartın.
5. Gerçek zamanlı aydınlatmayı devre dışı bırakmak için SetLights işlevine null veya boş bir liste verin.

Gerçek Zamanlı Aydınlatma API'leri

LCC Unity SDK, LCCManager üzerinden aşağıdaki iki gerçek zamanlı aydınlatma API'sini sunar. İkisi de LCC sahnesinin yüklenmesi tamamlandıktan sonra (yani onComplete geri çağrısında) çağrılmalıdır.

SetLights

// Return value: int → 0 = success, -1 = exceeded the maximum count limit
public int SetLights(List<PointLightData> lights)

Özel nokta ışığı listesini ayarlar. null veya boş bir liste verilmesi özel aydınlatmayı devre dışı bırakır.

Kullanım örneği:

using Unity.Mathematics; // float3

var lights = new List<PointLightData>();
lights.Add(new PointLightData {
    position = new float3(0, 5, 0),
    lightType = 0,              // 0=point light, 1=spotlight
    color = new float3(1, 1, 1),
    intensity = 2f,
    range = 10f
});
m_manager.SetLights(lights);

Notlar:

• Alan türü Vector4 değil, Unity.Mathematics.float3 türündedir; color alfa bileşeni içermez.
• lightType: 0 = nokta ışığı (direction / spotAngle değerlerini yok sayar), 1 = spot ışığı (direction / spotAngle gerektirir).
• En fazla sayı 50'dir (nokta ışıkları ve spot ışıkları toplamı); aşıldığında -1 döndürür.
• null veya boş bir liste verilmesi özel aydınlatmayı devre dışı bırakır.
• Etkinleştirildiğinde _USERLIGHT shader anahtar sözcüğü etkinleşir.
• UnityEngine zaten LightData tanımladığı için, belirsizliği önlemek amacıyla veri yapısına PointLightData adı verilmiştir.

SetLightIntensity

// Return value: void
public void SetLightIntensity(float intensity)

Genel aydınlatma yoğunluğunu ayarlar; aşırı pozlamayı önlemek için yeniden aydınlatmadan önce 3DGS sahnesini karartmakta kullanılır.

Kullanım örneği:

m_manager.SetLightIntensity(0.5f);

Notlar:

• Varsayılan değer 0.5 şeklindedir.
• Aralık [0, 1]; aralık dışındaki değerler otomatik olarak sınırlandırılır.
• Değer büyüdükçe 3DGS sahnesinin tamamı daha fazla kararır.

PointLightData Veri Yapısı

public struct PointLightData {
    public float3 position;    // world position
    public int lightType;      // 0=point light, 1=spotlight
    public float3 color;       // rgb color (no alpha component)
    public float intensity;    // light intensity
    public float3 direction;   // spotlight direction (ignored for point lights)
    public float range;        // light range
    public float spotAngle;    // spotlight cone angle (degrees, ignored for point lights)
    public float3 pad;         // alignment padding, no assignment needed
}