SceneCaptureSensor.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/Sensor/PixelReader.h"
#include "Carla/Sensor/RHIGPUReadbackPool.h"
#include "Carla/Sensor/Sensor.h"
#include "Carla/Sensor/UE4_Overridden/SceneCaptureComponent2D_CARLA.h"
#include "Carla/Sensor/ImageUtil.h"
#include "Carla/Sensor/PostProcessConfig.h"
#include "Carla/Sensor/ShowOnlyFilter.h"
 
#include <type_traits>
 
#include <util/ue-header-guard-begin.h>
#include "Async/Async.h"
#if __has_include("GBufferView.h")
#define CARLA_HAS_GBUFFER_API
#include "GBufferView.h"
#endif
#include <util/ue-header-guard-end.h>
 
#include "SceneCaptureSensor.generated.h"
 
class UDrawFrustumComponent;
class UStaticMeshComponent;
class UTextureRenderTarget2D;
class APostProcessVolume;
 
struct FCameraGBufferUint8
{
  /// Prevent this sensor to be spawned by users.
  using not_spawnable = void;
 
  void SetDataStream(FDataStream InStream)
  {
    Stream = std::move(InStream);
  }
 
  /// Replace the Stream associated with this sensor.
  void SetStream(FDataMultiStream InStream)
  {
    Stream = std::move(InStream);
  }
  /// Return the token that allows subscribing to this sensor's stream.
  auto GetToken() const
  {
    bIsUsed = true;
    return Stream.GetToken();
  }
 
  /// Dummy. Required for compatibility with other sensors only.
  FTransform GetActorTransform() const
  {
    return {};
  }
  /// Return the FDataStream associated with this sensor.
  ///
  /// You need to provide a reference to self, this is necessary for template
  /// deduction.
  template <typename SensorT>
  FAsyncDataStream GetDataStream(const SensorT &Self)
  {
    return Stream.MakeAsyncDataStream(Self, Self.GetEpisode().GetElapsedGameTime());
  }
 
  mutable bool bIsUsed = false;
  FDataStream Stream;
};
 
struct FCameraGBufferFloat
{
  /// Prevent this sensor to be spawned by users.
  using not_spawnable = void;
 
  void SetDataStream(FDataStream InStream)
  {
    Stream = std::move(InStream);
  }
 
  /// Replace the Stream associated with this sensor.
  void SetStream(FDataMultiStream InStream)
  {
    Stream = std::move(InStream);
  }
  /// Return the token that allows subscribing to this sensor's stream.
  auto GetToken() const
  {
    bIsUsed = true;
    return Stream.GetToken();
  }
  /// Dummy. Required for compatibility with other sensors only.
  FTransform GetActorTransform() const
  {
    return {};
  }
  /// Return the FDataStream associated with this sensor.
  ///
  /// You need to provide a reference to self, this is necessary for template
  /// deduction.
  template <typename SensorT>
  FAsyncDataStream GetDataStream(const SensorT &Self)
  {
    return Stream.MakeAsyncDataStream(Self, Self.GetEpisode().GetElapsedGameTime());
  }
 
  mutable bool bIsUsed = false;
  FDataStream Stream;
};
 
/// Base class for sensors using a USceneCaptureComponent2D for rendering the
/// scene. This class does not capture data, use
/// `FPixelReader::SendPixelsInRenderThread<FColor>(*this)` in derived classes.
///
/// To access the USceneCaptureComponent2D override the
/// SetUpSceneCaptureComponent function.
///
/// @warning All the setters should be called before BeginPlay.
UCLASS(Abstract)
class CARLA_API ASceneCaptureSensor : public ASensor
{
  GENERATED_BODY()
 
  friend class ACarlaGameModeBase;
  friend class FPixelReader;
  friend class FPixelReader2;
 
public:
  ASceneCaptureSensor(const FObjectInitializer &ObjectInitializer);
 
  void Set(const FActorDescription &ActorDescription) override;
 
  void SetImageSize(uint32 Width, uint32 Height);
 
  USceneCaptureComponent2D_CARLA *GetCaptureComponent() const
  {
    return CaptureComponent2D;
  }
  
  uint32 GetImageWidth() const
  {
    return ImageWidth;
  }
 
  uint32 GetImageHeight() const
  {
    return ImageHeight;
  }
 
  UFUNCTION(BlueprintCallable)
  void EnablePostProcessingEffects(bool Enable = true)
  {
    bEnablePostProcessingEffects = Enable;
  }
 
  UFUNCTION(BlueprintCallable)
  bool ArePostProcessingEffectsEnabled() const
  {
    return bEnablePostProcessingEffects;
  }
 
  /// Render the capture at ScreenPercentage (25-100) of the target resolution
  /// and upscale it back with DLSS Super Resolution when available (bilinear
  /// otherwise). 100 or Enable=false keeps the stock full-resolution path.
  UFUNCTION(BlueprintCallable)
  void SetDLSSUpscale(bool Enable, float ScreenPercentage)
  {
    bEnableDLSSUpscale = Enable;
    DLSSScreenPercentage = FMath::Clamp(ScreenPercentage, 25.0f, 100.0f);
  }
 
  UFUNCTION(BlueprintCallable)
  bool IsDLSSUpscaleEnabled() const
  {
    return bEnableDLSSUpscale;
  }
 
  UFUNCTION(BlueprintCallable)
  void SetUseRayTracing(bool Enable);
 
  UFUNCTION(BlueprintCallable)
  bool GetUseRayTracing() const
  {
    return bUseRayTracing;
  }
 
  /// Applies the `carla.Camera.UseRayTracing` tier policy to a camera's own
  /// ray-tracing preference. A camera that cannot render without ray tracing
  /// passes `bRequired` and is never switched off by the policy.
  static bool ResolveCameraRayTracing(bool bSensorEnabled, bool bRequired);
 
  /// Show-only render mode (see FCarlaShowOnlyFilter): comma separated
  /// semantic label names. Non-empty restricts the capture to the actors
  /// carrying those labels (plus the shadow catchers and explicit ids).
  UFUNCTION(BlueprintCallable)
  void SetShowOnlyTags(const FString &CommaSeparatedLabels)
  {
    ShowOnlyFilter.SetShowOnlyTags(CommaSeparatedLabels);
  }
 
  /// Labels whose actors are rendered alongside the show-only set so they
  /// receive its cast shadows ("Roads,Sidewalks"). No effect when the
  /// show-only mode is off.
  UFUNCTION(BlueprintCallable)
  void SetShadowCatcherTags(const FString &CommaSeparatedLabels)
  {
    ShowOnlyFilter.SetShadowCatcherTags(CommaSeparatedLabels);
  }
 
  /// CARLA actor ids always included in the show-only set.
  UFUNCTION(BlueprintCallable)
  void SetShowOnlyActorIds(const FString &CommaSeparatedIds)
  {
    ShowOnlyFilter.SetShowOnlyActorIds(CommaSeparatedIds);
  }
 
  UFUNCTION(BlueprintCallable)
  bool IsShowOnlyEnabled() const
  {
    return ShowOnlyFilter.IsEnabled();
  }
 
  const FCarlaShowOnlyFilter &GetShowOnlyFilter() const
  {
    return ShowOnlyFilter;
  }
 
  UFUNCTION(BlueprintCallable)
  void Enable16BitFormat(bool Enable = false)
  {
    bEnable16BitFormat = Enable;
  }
 
  UFUNCTION(BlueprintCallable)
  bool Is16BitFormatEnabled() const
  {
    return bEnable16BitFormat;
  }
 
  UFUNCTION(BlueprintCallable)
  void SetFOVAngle(float FOVAngle);
 
  UFUNCTION(BlueprintCallable)
  float GetFOVAngle() const;
 
  UFUNCTION(BlueprintCallable)
  void SetTargetGamma(float InTargetGamma)
  {
    TargetGamma = InTargetGamma;
  }
 
  UFUNCTION(BlueprintCallable)
  float GetTargetGamma() const
  {
    return TargetGamma;
  }
 
  UFUNCTION(BlueprintCallable)
  void SetBloomMethod(EBloomMethod Method);
 
  UFUNCTION(BlueprintCallable)
  EBloomMethod GetBloomMethod() const;
 
  UFUNCTION(BlueprintCallable)
  FVector4 GetGlobalGain() const;
 
  UFUNCTION(BlueprintCallable)
  void SetGlobalGain(FVector4 Gain);
 
  UFUNCTION(BlueprintCallable)
  float GetBlueCorrection() const;
 
  UFUNCTION(BlueprintCallable)
  void SetBlueCorrection(float Val);
 
  UFUNCTION(BlueprintCallable)
  float GetDetailStrength() const;
 
  UFUNCTION(BlueprintCallable)
  void SetDetailStrength(float Val);
 
  UFUNCTION(BlueprintCallable)
  float GetFilmGrainIntensity() const;
 
  UFUNCTION(BlueprintCallable)
  void SetFilmGrainIntensity(float Val);
 
  UFUNCTION(BlueprintCallable)
  void SetAOIntensity(float Intensity);
 
  UFUNCTION(BlueprintCallable)
  float GetAOIntensity() const;
 
  UFUNCTION(BlueprintCallable)
  void SetAORadius(float Radius);
 
  UFUNCTION(BlueprintCallable)
  float GetAORadius() const;
 
  UFUNCTION(BlueprintCallable)
  void SetExposureMethod(EAutoExposureMethod Method);
 
  UFUNCTION(BlueprintCallable)
  EAutoExposureMethod GetExposureMethod() const;
 
  UFUNCTION(BlueprintCallable)
  void SetLocalExposureMethod(ELocalExposureMethod Method);
 
  UFUNCTION(BlueprintCallable)
  ELocalExposureMethod GetLocalExposureMethod() const;
 
  UFUNCTION(BlueprintCallable)
  UTexture2D *GetBloomKernelTexture() const;
 
  UFUNCTION(BlueprintCallable)
  void SetBloomConvolutionTexture(UTexture2D *Texture);
 
  UFUNCTION(BlueprintCallable)
  void SetExposureCompensation(float Compensation);
 
  UFUNCTION(BlueprintCallable)
  float GetExposureCompensation() const;
 
  UFUNCTION(BlueprintCallable)
  float GetDirtMaskIntensity() const;
 
  UFUNCTION(BlueprintCallable)
  void SetDirtMaskIntensity(float Intensity);
 
  UFUNCTION(BlueprintCallable)
  void SetShutterSpeed(float Speed);
 
  UFUNCTION(BlueprintCallable)
  float GetShutterSpeed() const;
 
  UFUNCTION(BlueprintCallable)
  void SetISO(float ISO);
 
  UFUNCTION(BlueprintCallable)
  float GetISO() const;
 
  UFUNCTION(BlueprintCallable)
  void SetAperture(float Aperture);
 
  UFUNCTION(BlueprintCallable)
  float GetAperture() const;
 
  UFUNCTION(BlueprintCallable)
  void SetSensorWidth(float Width);
 
  UFUNCTION(BlueprintCallable)
  float GetSensorWidth() const;
 
  UFUNCTION(BlueprintCallable)
  void SetFocalDistance(float Distance);
 
  UFUNCTION(BlueprintCallable)
  float GetFocalDistance() const;
 
  UFUNCTION(BlueprintCallable)
  void SetDepthBlurAmount(float Amount);
 
  UFUNCTION(BlueprintCallable)
  float GetDepthBlurAmount() const;
 
  UFUNCTION(BlueprintCallable)
  void SetDepthBlurRadius(float Radius);
 
  UFUNCTION(BlueprintCallable)
  float GetDepthBlurRadius() const;
 
  UFUNCTION(BlueprintCallable)
  void SetBladeCount(int Count);
 
  UFUNCTION(BlueprintCallable)
  int GetBladeCount() const;
 
  UFUNCTION(BlueprintCallable)
  void SetDepthOfFieldMinFstop(float MinFstop);
 
  UFUNCTION(BlueprintCallable)
  float GetDepthOfFieldMinFstop() const;
 
  UFUNCTION(BlueprintCallable)
  void SetFilmSlope(float Slope);
 
  UFUNCTION(BlueprintCallable)
  float GetFilmSlope() const;
 
  UFUNCTION(BlueprintCallable)
  void SetFilmToe(float Toe);
 
  UFUNCTION(BlueprintCallable)
  float GetFilmToe() const;
 
  UFUNCTION(BlueprintCallable)
  void SetFilmShoulder(float Shoulder);
 
  UFUNCTION(BlueprintCallable)
  float GetFilmShoulder() const;
 
  UFUNCTION(BlueprintCallable)
  void SetFilmBlackClip(float BlackClip);
 
  UFUNCTION(BlueprintCallable)
  float GetFilmBlackClip() const;
 
  UFUNCTION(BlueprintCallable)
  void SetFilmWhiteClip(float WhiteClip);
 
  UFUNCTION(BlueprintCallable)
  float GetFilmWhiteClip() const;
 
  UFUNCTION(BlueprintCallable)
  void SetExposureMinBrightness(float Brightness);
 
  UFUNCTION(BlueprintCallable)
  float GetExposureMinBrightness() const;
 
  UFUNCTION(BlueprintCallable)
  void SetExposureMaxBrightness(float Brightness);
 
  UFUNCTION(BlueprintCallable)
  float GetExposureMaxBrightness() const;
 
  UFUNCTION(BlueprintCallable)
  void SetExposureSpeedDown(float Speed);
 
  UFUNCTION(BlueprintCallable)
  float GetExposureSpeedDown() const;
 
  UFUNCTION(BlueprintCallable)
  void SetExposureSpeedUp(float Speed);
 
  UFUNCTION(BlueprintCallable)
  float GetExposureSpeedUp() const;
 
  UFUNCTION(BlueprintCallable)
  void SetExposureCalibrationConstant(float Constant);
 
  UFUNCTION(BlueprintCallable)
  float GetExposureCalibrationConstant() const;
 
  UFUNCTION(BlueprintCallable)
  void SetMotionBlurIntensity(float Intensity);
 
  UFUNCTION(BlueprintCallable)
  float GetMotionBlurIntensity() const;
 
  UFUNCTION(BlueprintCallable)
  void SetMotionBlurMaxDistortion(float MaxDistortion);
 
  UFUNCTION(BlueprintCallable)
  float GetMotionBlurMaxDistortion() const;
 
  UFUNCTION(BlueprintCallable)
  void SetMotionBlurMinObjectScreenSize(float ScreenSize);
 
  UFUNCTION(BlueprintCallable)
  float GetMotionBlurMinObjectScreenSize() const;
 
  UFUNCTION(BlueprintCallable)
  void SetLensFlareIntensity(float Intensity);
 
  UFUNCTION(BlueprintCallable)
  float GetLensFlareIntensity() const;
 
  UFUNCTION(BlueprintCallable)
  void SetBloomIntensity(float Intensity);
 
  UFUNCTION(BlueprintCallable)
  float GetBloomIntensity() const;
 
  UFUNCTION(BlueprintCallable)
  void SetWhiteTemp(float Temp);
 
  UFUNCTION(BlueprintCallable)
  float GetWhiteTemp() const;
 
  UFUNCTION(BlueprintCallable)
  void SetWhiteTint(float Tint);
 
  UFUNCTION(BlueprintCallable)
  float GetWhiteTint() const;
 
  UFUNCTION(BlueprintCallable)
  void SetChromAberrIntensity(float Intensity);
 
  UFUNCTION(BlueprintCallable)
  float GetChromAberrIntensity() const;
 
  UFUNCTION(BlueprintCallable)
  void SetChromAberrOffset(float ChromAberrOffset);
 
  UFUNCTION(BlueprintCallable)
  float GetChromAberrOffset() const;
 
  UFUNCTION(BlueprintCallable)
  void SetColorSaturation(FVector4 ColorSaturation);
 
  UFUNCTION(BlueprintCallable)
  FVector4 GetColorSaturation() const;
 
  UFUNCTION(BlueprintCallable)
  void SetColorSaturationMidtones(FVector4 ColorSaturation);
 
  UFUNCTION(BlueprintCallable)
  FVector4 GetColorSaturationMidtones() const;
 
  UFUNCTION(BlueprintCallable)
  void SetColorSaturationHighlights(FVector4 ColorSaturation);
 
  UFUNCTION(BlueprintCallable)
  FVector4 GetColorSaturationHighlights() const;
 
  UFUNCTION(BlueprintCallable)
  void SetColorContrast(FVector4 ColorContrast);
 
  UFUNCTION(BlueprintCallable)
  FVector4 GetColorContrast() const;
 
  UFUNCTION(BlueprintCallable)
  void SetColorContrastMidtones(FVector4 ColorContrast);
 
  UFUNCTION(BlueprintCallable)
  FVector4 GetColorContrastMidtones() const;
 
  UFUNCTION(BlueprintCallable)
  void SetColorContrastHighlights(FVector4 ColorContrast);
 
  UFUNCTION(BlueprintCallable)
  FVector4 GetColorContrastHighlights() const;
 
  UFUNCTION(BlueprintCallable)
  void SetColorGamma(FVector4 ColorGamma);
 
  UFUNCTION(BlueprintCallable)
  FVector4 GetColorGamma() const;
 
  UFUNCTION(BlueprintCallable)
  void SetHighlightsGamma(FVector4 HighlightsGamma);
 
  UFUNCTION(BlueprintCallable)
  FVector4 GetHighlightsGamma() const;
 
  UFUNCTION(BlueprintCallable)
  void SetToneCurveAmount(float ToneCurveAmount);
 
  UFUNCTION(BlueprintCallable)
  float GetToneCurveAmount() const;
 
  UFUNCTION(BlueprintCallable)
  void SetSceneColorTint(FLinearColor SceneColorTint);
 
  UFUNCTION(BlueprintCallable)
  FLinearColor GetSceneColorTint() const;
 
  UFUNCTION(BlueprintCallable)
  void SetVignetteIntensity(float VignetteIntensity);
 
  UFUNCTION(BlueprintCallable)
  float GetVignetteIntensity() const;
 
  UFUNCTION(BlueprintCallable)
  void SetHighlightContrastScale(float HighlightContrastScale);
 
  UFUNCTION(BlueprintCallable)
  float GetHighlightContrastScale() const;
 
  UFUNCTION(BlueprintCallable)
  void SetShadowContrastScale(float ShadowContrastScale);
 
  UFUNCTION(BlueprintCallable)
  float GetShadowContrastScale() const;
 
  virtual void UpdatePostProcessConfig(
      FPostProcessConfig &InOutPostProcessConfig);
 
  /// Use for debugging purposes only.
  UFUNCTION(BlueprintCallable)
  bool ReadPixels(TArray<FColor> &BitMap) const
  {
    check(CaptureRenderTarget != nullptr);
    return FPixelReader::WritePixelsToArray(*CaptureRenderTarget, BitMap);
  }
 
  /// Use for debugging purposes only.
  UFUNCTION(BlueprintCallable)
  void SaveCaptureToDisk(const FString &FilePath) const
  {
    check(CaptureRenderTarget != nullptr);
    FPixelReader::SavePixelsToDisk(*CaptureRenderTarget, FilePath);
  }
 
  UFUNCTION(BlueprintCallable)
  USceneCaptureComponent2D *GetCaptureComponent2D()
  {
    return CaptureComponent2D;
  }
 
  UFUNCTION(BlueprintCallable)
  UTextureRenderTarget2D *GetCaptureRenderTarget()
  {
    return CaptureRenderTarget;
  }
 
  /// Per-sensor pool of recyclable RHI readback objects. May be null before
  /// BeginPlay or after EndPlay; consumers fall back to a per-call alloc in
  /// that case.
  FRHIGPUReadbackPoolPtr GetReadbackPool() const { return ReadbackPool; }
 
  /// Immediate enqueues render commands of the scene at the current time.
  void EnqueueRenderSceneImmediate();
 
  /// Blocks until the render thread has finished all it's tasks.
  void WaitForRenderThreadToFinish()
  {
    TRACE_CPUPROFILER_EVENT_SCOPE(ASceneCaptureSensor::WaitForRenderThreadToFinish);
    // FlushRenderingCommands();
  }
 
  struct
  {
    FCameraGBufferUint8 SceneColor;
    FCameraGBufferUint8 SceneDepth;
    FCameraGBufferUint8 SceneStencil;
    FCameraGBufferUint8 GBufferA;
    FCameraGBufferUint8 GBufferB;
    FCameraGBufferUint8 GBufferC;
    FCameraGBufferUint8 GBufferD;
    FCameraGBufferUint8 GBufferE;
    FCameraGBufferUint8 GBufferF;
    FCameraGBufferUint8 Velocity;
    FCameraGBufferUint8 SSAO;
    FCameraGBufferUint8 CustomDepth;
    FCameraGBufferUint8 CustomStencil;
  } CameraGBuffers;
 
  UFUNCTION(BlueprintCallable)
  static bool ApplyPostProcessVolumeToSensor(APostProcessVolume *Origin, ASceneCaptureSensor *Dest, bool bOverrideCurrentCamera = false);
 
protected:
  /// True for sensors that cannot render without hardware ray tracing
  /// (path-traced lens cameras); the tier policy never switches them off.
  virtual bool RequiresRayTracing() const
  {
    return false;
  }
 
  void CaptureSceneExtended();
 
#ifdef CARLA_HAS_GBUFFER_API
  virtual void SendGBufferTextures(FGBufferRequest &GBuffer);
#endif
 
  virtual void BeginPlay() override;
 
  virtual void PrePhysTick(float DeltaSeconds) override;
  virtual void PostPhysTick(UWorld *World, ELevelTick TickType, float DeltaTime) override;
 
  /// Motion blur from the auto exposure time (carla.Camera.ExposureMotionBlur).
  void UpdateExposureMotionBlur(UWorld *World, float DeltaTime);
 
  /// Simulation time of this sensor's previous capture (-1 before the first).
  double LastCaptureTime = -1.0;
 
  /// Exposure time of the last capture in seconds (exposure-linked motion blur).
  float ExposureSeconds = 0.0f;
 
  virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
  virtual void SetUpSceneCaptureComponent(USceneCaptureComponent2D &SceneCapture) {}
 
  /// Render target necessary for scene capture.
  UPROPERTY(VisibleAnywhere)
  TObjectPtr<UTextureRenderTarget2D> CaptureRenderTarget = nullptr;
 
  /// Scene capture component.
  UPROPERTY(VisibleAnywhere)
  TObjectPtr<USceneCaptureComponent2D_CARLA> CaptureComponent2D = nullptr;
 
  // Standard RGB/depth/segmentation cameras (MakeCameraDefinition) never
  // register a "gamma" blueprint attribute -- only Wide Angle Lens and
  // RayTraced Lens cameras do, defaulting it to 2.2 (sRGB). Client code that
  // guards on bp.has_attribute('gamma') before setting it (e.g.
  // manual_control.py's --gamma) silently no-ops for the standard camera, so
  // this default is the only gamma that ever actually applies to it. 2.4
  // reads visibly brighter/blown-out next to the editor/server's own ~2.2
  // display gamma; match it instead.
  UPROPERTY(EditAnywhere)
  float TargetGamma = 2.2f;
 
  /// Image width in pixels.
  UPROPERTY(EditAnywhere)
  uint32 ImageWidth = 800u;
 
  /// Image height in pixels.
  UPROPERTY(EditAnywhere)
  uint32 ImageHeight = 600u;
 
  /// Whether to render the post-processing effects present in the scene.
  UPROPERTY(EditAnywhere)
  bool bEnablePostProcessingEffects = true;
 
  /// Whether this sensor uses hardware ray tracing for its scene capture.
  /// Defaults to true so cameras follow upstream behaviour out of the box.
  /// Setting false saves ~700 MiB-1 GiB on the GPU and is intended for
  /// sensors that do not need RT (depth, semantic, lidar). The global CVar
  /// carla.Camera.UseRayTracing forces on/off across every camera regardless
  /// of the per-sensor attribute.
  UPROPERTY(EditAnywhere)
  bool bUseRayTracing = true;
 
  /// Whether to change render target format to PF_A16B16G16R16, offering 16bit / channel
  UPROPERTY(EditAnywhere)
  bool bEnable16BitFormat = false;
 
  /// Render the capture at DLSSScreenPercentage of the target resolution and
  /// upscale back with DLSS Super Resolution (engine scene-capture temporal
  /// upscaler; bilinear fallback without NVIDIA hardware). Off by default:
  /// non-NVIDIA users keep the stock full-resolution path. Requires
  /// bEnablePostProcessingEffects (the capture needs a temporal AA method for
  /// DLSS to engage; without one the engine spatially upscales instead).
  UPROPERTY(EditAnywhere)
  bool bEnableDLSSUpscale = false;
 
  /// Internal render resolution as a percentage of the target resolution when
  /// bEnableDLSSUpscale is set. 50 = quarter of the pixels, 33 = one ninth.
  UPROPERTY(EditAnywhere)
  float DLSSScreenPercentage = 50.0f;
 
  /// Per-sensor pool of recyclable RHI readback objects. Created in BeginPlay,
  /// dropped in EndPlay; outstanding AsyncTasks keep it alive via shared
  /// ownership.
  FRHIGPUReadbackPoolPtr ReadbackPool;
 
  /// Show-only actor filter, applied to the capture component right before
  /// every capture (see FCarlaShowOnlyFilter).
  FCarlaShowOnlyFilter ShowOnlyFilter;
 
  /// Returns true if any GBuffer stream has an active listener.
  bool IsAnyGBufferClientListening() const;
 
  /// Aggregate gate: main stream or any GBuffer stream has listeners,
  /// or CVarCarlaCameraForceAllGBuffers forces every frame.
  /// Non-const because ASensor::AreClientsListening() is non-const.
  bool ShouldCaptureThisFrame();
 
private:
  void ApplyRayTracingSetting();
 
  /// Captures rendered as camera cuts since BeginPlay (carla.Camera.SpawnCameraCuts).
  int32 NumCaptures = 0;
 
#ifdef CARLA_HAS_GBUFFER_API
  template <
      typename SensorT,
      typename CameraGBufferT>
  static void SendGBuffer(
      SensorT &Self,
      CameraGBufferT &CameraGBuffer,
      FGBufferRequest &GBufferData,
      EGBufferTextureID TextureID)
  {
    using PixelType = typename std::conditional<
        std::is_same<std::remove_reference_t<CameraGBufferT>, FCameraGBufferUint8>::value,
        FColor,
        FLinearColor>::type;
    FIntPoint ViewSize;
    TArray<PixelType> Pixels;
    if (GBufferData.WaitForTextureTransfer(TextureID))
    {
      TRACE_CPUPROFILER_EVENT_SCOPE_STR("GBuffer Decode");
      void *PixelData;
      int32 SourcePitch;
      FIntPoint SourceExtent;
      GBufferData.MapTextureData(
          TextureID,
          PixelData,
          SourcePitch,
          SourceExtent);
      auto Format = GBufferData.Readbacks[(size_t)TextureID]->GetFormat();
      ViewSize = GBufferData.ViewRect.Size();
      Pixels.AddUninitialized(ViewSize.X * ViewSize.Y);
      FReadSurfaceDataFlags Flags = {};
      Flags.SetLinearToGamma(true);
      ImageUtil::DecodePixelsByFormat(
          PixelData,
          SourcePitch,
          SourceExtent,
          ViewSize,
          Format,
          Flags,
          Pixels);
      GBufferData.UnmapTextureData(TextureID);
    }
    else
    {
      ViewSize = GBufferData.ViewRect.Size();
      Pixels.SetNum(ViewSize.X * ViewSize.Y);
      for (auto &Pixel : Pixels)
        Pixel = PixelType::Black;
    }
    auto GBufferStream = CameraGBuffer.GetDataStream(Self);
    auto Buffer = GBufferStream.PopBufferFromPool();
    Buffer.copy_from(
        carla::sensor::SensorRegistry::get<CameraGBufferT *>::type::header_offset,
        Pixels);
    if (Buffer.empty())
    {
      return;
    }
    SCOPE_CYCLE_COUNTER(STAT_CarlaSensorStreamSend);
    TRACE_CPUPROFILER_EVENT_SCOPE_STR("Stream Send");
    GBufferStream.SerializeAndSend(
        CameraGBuffer,
        std::move(Buffer),
        ViewSize.X,
        ViewSize.Y,
        Self.GetFOVAngle());
  }
#endif
 
protected:
#ifdef CARLA_HAS_GBUFFER_API
  template <typename T>
  void SendGBufferTexturesInternal(T &Self, FGBufferRequest &GBufferData)
  {
    for (size_t i = 0; i != FGBufferRequest::TextureCount; ++i)
    {
      if ((GBufferData.DesiredTexturesMask & (UINT64_C(1) << i)) == 0)
      {
        continue;
      }
      auto &C = CameraGBuffers;
      EGBufferTextureID ID = (EGBufferTextureID)i;
      switch (ID)
      {
      case EGBufferTextureID::SceneColor:
        SendGBuffer(Self, C.SceneColor, GBufferData, ID);
        break;
      case EGBufferTextureID::SceneDepth:
        SendGBuffer(Self, C.SceneDepth, GBufferData, ID);
        break;
      case EGBufferTextureID::SceneStencil:
        SendGBuffer(Self, C.SceneStencil, GBufferData, ID);
        break;
      case EGBufferTextureID::GBufferA:
        SendGBuffer(Self, C.GBufferA, GBufferData, ID);
        break;
      case EGBufferTextureID::GBufferB:
        SendGBuffer(Self, C.GBufferB, GBufferData, ID);
        break;
      case EGBufferTextureID::GBufferC:
        SendGBuffer(Self, C.GBufferC, GBufferData, ID);
        break;
      case EGBufferTextureID::GBufferD:
        SendGBuffer(Self, C.GBufferD, GBufferData, ID);
        break;
      case EGBufferTextureID::GBufferE:
        SendGBuffer(Self, C.GBufferE, GBufferData, ID);
        break;
      case EGBufferTextureID::GBufferF:
        SendGBuffer(Self, C.GBufferF, GBufferData, ID);
        break;
      case EGBufferTextureID::Velocity:
        SendGBuffer(Self, C.Velocity, GBufferData, ID);
        break;
      case EGBufferTextureID::SSAO:
        SendGBuffer(Self, C.SSAO, GBufferData, ID);
        break;
      case EGBufferTextureID::CustomDepth:
        SendGBuffer(Self, C.CustomDepth, GBufferData, ID);
        break;
      case EGBufferTextureID::CustomStencil:
        SendGBuffer(Self, C.CustomStencil, GBufferData, ID);
        break;
      default:
        abort();
      }
    }
  }
#endif
};