CarlaLightSubsystem.h

Go to the documentation of this file.

// Copyright (c) 2026 Computer Vision Center (CVC) at the Universitat Autonoma
// de Barcelona (UAB).
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#pragma once
 
#include "Carla.h"
#include "CarlaLight.h"
 
#include <util/disable-ue4-macros.h>
#include <carla/rpc/LightState.h>
#include <util/enable-ue4-macros.h>
 
#include <util/ue-header-guard-begin.h>
#include "CoreMinimal.h"
#include "Subsystems/WorldSubsystem.h"
#include <util/ue-header-guard-end.h>
 
#include <vector>
 
#include "CarlaLightSubsystem.generated.h"
 
/**
 *
 */
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FDayTimeChanged, bool, bIsDay);
 
UCLASS(Blueprintable, BlueprintType)
class CARLA_API UCarlaLightSubsystem : public UWorldSubsystem
{
  GENERATED_BODY()
 
  //using cr = carla::rpc;
 
public:
 
  // Begin USubsystem
  void Initialize(FSubsystemCollectionBase& Collection) override;
  // End USubsystem
  void Deinitialize() override;
 
  void RegisterLight(UCarlaLight* CarlaLight);
 
  void UnregisterLight(UCarlaLight* CarlaLight);
 
  UFUNCTION(BlueprintCallable)
  bool IsUpdatePending() const;
 
  UFUNCTION(BlueprintCallable)
  int32 NumLights() const {
    return Lights.Num();
  }
 
  std::vector<carla::rpc::LightState> GetLights(FString Client);
 
  void SetLights(
      FString Client,
      std::vector<carla::rpc::LightState> LightsToSet,
      bool DiscardClient = false);
 
  UCarlaLight* GetLight(int Id);
 
  TMap<int, UCarlaLight* >& GetLights()
  {
    return Lights;
  }
 
  void SetDayNightCycle(const bool active);
 
  bool GetDayNightCycle() const
  {
    return bDayNightCycle;
  }
 
  /// The day/night state last broadcast, if any.
  bool GetDayTimeState(bool &bOutIsDay) const
  {
    bOutIsDay = bLastIsDay;
    return bHasDayTimeState;
  }
 
  UPROPERTY(BlueprintCallable, BlueprintAssignable, Category = "DayTimeChangeEvent")
  FDayTimeChanged DayTimeChangeEvent;
 
  /// Broadcast a day/night change and then re-apply the UE4->UE5 component
  /// intensity conversion on every registered light. Use this instead of
  /// broadcasting DayTimeChangeEvent directly: blueprint-bound handlers push
  /// raw authored intensities into the light components, undoing any
  /// conversion applied earlier in the same broadcast.
  void NotifyDayTimeChange(bool bIsDay);
 
  /// Flag every registered client (except ClientThatUpdate) so their
  /// LightManager re-queries light states. Must be called after any
  /// server-side state change made outside a client request (day/night
  /// broadcast, recorder replay), or clients keep serving stale cached
  /// values.
  void SetClientStatesdirty(FString ClientThatUpdate);
 
private:
 
  // UPROPERTY so the GC can see these references: a bare map dangles when
  // World Partition streams out a lamp before its EndPlay unregisters it.
  UPROPERTY()
  TMap<int, UCarlaLight* > Lights;
 
  // Last state NotifyDayTimeChange broadcast, applied (next tick) to lights registering later.
  void ScheduleDayTimeState(UCarlaLight* CarlaLight);
  bool bHasDayTimeState = false;
  bool bLastIsDay = true;
  // set_day_night_cycle from the client; off, day/night changes are ignored.
  bool bDayNightCycle = true;
  TSet<TWeakObjectPtr<UCarlaLight>> PendingDayTimeLights;
 
  // Flag for each client to tell if an update needs to be done
  TMap<FString, bool> ClientStates;
  // Since the clients doesn't have a proper id on the simulation,
  // I use the host : port pair.
 
};