Does jetbrains work with blueprints
Not directly.
JetBrains (Rider, CLion, etc.) integrates with Unreal Engine **for C++**, not for Blueprints. Epic’s Blueprint system is fully visual and only runs inside the Unreal Editor — JetBrains can’t open or edit those graphs.
What Rider for Unreal *can* do:
– Full C++/Unreal reflection support (UCLASS, UPROPERTY, etc.)
– Navigate between C++ and the Blueprint that inherits from it (via RiderLink plugin).
– Show references to Blueprint assets when they call into your C++ code.
– Debug UE projects (C++ side).
What it *cannot do*:
– Edit Blueprints visually.
– Compile or hot-reload Blueprints independently of the UE Editor.
So the workflow is: **use JetBrains Rider (or VS/VS Code) for C++ code, and Unreal Editor for Blueprints.**
👉 But Rider does give you nice cross-links: if a Blueprint is based on a C++ class you wrote, Rider can show usages and navigate to it.
Do you want me to lay out exactly how to set up Rider + RiderLink so you can jump between Blueprints and C++ smoothly?
where is the feature to quickly add lighting, fog clouds etc to a level
That’s in the **Unreal Engine “Place Actors” panel**.
Quick path in **UE5.6**:
– Open your **Level** in the viewport.
– On the left side (default layout), open the **Place Actors** panel (if it’s closed: `Window > Place Actors`).
– There’s a category called **Lights** (Directional Light, Point Light, Spot Light, Rect Light, Sky Light).
– There’s also **Visual Effects** (Atmospheric Fog, Exponential Height Fog, Volumetric Cloud, Sky Atmosphere, etc.).
From there you just drag & drop into the level.
For speed:
– Use the **Quick Add dropdown** in the toolbar (`+ Add` at the top of the viewport). That’s the fastest way to add lights, fog, volumes, and other common actors.
⚡ So: **`+ Add` button in the toolbar, or Place Actors panel.**
Want me to map out which ones you need for a full day/night sky setup (sun, fog, atmosphere, clouds, skybox)?
how to put in a skydome
In **UE5.6** you don’t get the old “BP_SkySphere” (that was UE4). Instead you’ve got two main options:
—
### 🔹 Method 1: Modern Sky & Atmosphere (recommended)
1. Go to the **toolbar** → **`+ Add`** → **Visual Effects**.
2. Drag in:
– **Directional Light** (your Sun).
– **Sky Atmosphere** (renders the sky gradient).
– **Volumetric Cloud** (for clouds).
– **Exponential Height Fog** (for ground haze).
– **Sky Light** (captures lighting/reflections).
3. Rotate your **Directional Light** to set time of day — the sky will follow.
This gives you a fully dynamic, physically-based sky.
—
### 🔹 Method 2: Old-style SkyDome / SkySphere
If you want a *static* dome with a texture:
1. Go to **`+ Add` → Lights / Visual Effects → SkySphere** (may require enabling “Engine Content” in the Content Browser).
– If it’s not listed, search for **BP_SkySphere** in the Content Browser (enable *View Options → Show Engine Content*).
2. Place it in your level.
3. Assign a material/texture (usually a panoramic HDRI or starfield).
—
👉 **Rule of thumb:**
– Use **Sky Atmosphere + Clouds** if you want realism and day/night cycles.
– Use a **SkyDome mesh with a material** if you just want a backdrop (like space, stylized art, or fixed skies).
Do you want me to give you a **step-by-step to make a space skydome** (stars/galaxies) or a **realistic Earth sky**?
can these setting be nade in a C++ file?
Yep. You can create and tune the whole “sky stack” (sun, sky, fog, clouds, skylight) from C++.
Here’s a compact example you can drop into a bootstrap actor’s `BeginPlay()` (or call from your GameMode) to **spawn if missing** and set common params:
“`cpp
// SkySetupActor.h
#pragma once
#include “CoreMinimal.h”
#include “GameFramework/Actor.h”
#include “SkySetupActor.generated.h”
UCLASS()
class ASkySetupActor : public AActor
{
GENERATED_BODY()
public:
virtual void BeginPlay() override;
private:
template T* FindOrSpawn();
void EnsureSkyStack();
};
“`
“`cpp
// SkySetupActor.cpp
#include “SkySetupActor.h”
#include “Kismet/GameplayStatics.h”
#include “Engine/World.h”
// Sky
#include “Atmosphere/SkyAtmosphere.h”
#include “Engine/VolumetricCloud.h”
#include “Engine/ExponentialHeightFog.h”
#include “Components/ExponentialHeightFogComponent.h”
// Lights
#include “Engine/DirectionalLight.h”
#include “Components/DirectionalLightComponent.h”
#include “Engine/SkyLight.h”
#include “Components/SkyLightComponent.h”
template
T* ASkySetupActor::FindOrSpawn()
{
TArray Found;
UGameplayStatics::GetAllActorsOfClass(GetWorld(), T::StaticClass(), Found);
if (Found.Num() > 0) return Cast(Found[0]);
FActorSpawnParameters Params;
Params.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
return GetWorld()->SpawnActor(T::StaticClass(), FTransform::Identity, Params);
}
void ASkySetupActor::BeginPlay()
{
Super::BeginPlay();
EnsureSkyStack();
}
void ASkySetupActor::EnsureSkyStack()
{
// 1) Sun (Directional Light)
ADirectionalLight* Sun = FindOrSpawn();
if (UDirectionalLightComponent* SunComp = Sun->GetDirectionalLightComponent())
{
Sun->SetActorRotation(FRotator(-15.f, 45.f, 0.f)); // “time of day”
SunComp->SetMobility(EComponentMobility::Movable);
SunComp->SetIntensity(100000.0f); // lux-ish
SunComp->bUsedAsAtmosphereSunLight = true; // key link for SkyAtmosphere
SunComp->AtmosphereSunLightIndex = 0;
SunComp->bCastAtmosphereShadows = true;
}
// 2) Sky Atmosphere
ASkyAtmosphere* Sky = FindOrSpawn();
// Defaults are usually fine; tweak if desired:
// Sky->GetSkyAtmosphereComponent()->RayleighScatteringScale = 1.0f;
// 3) Volumetric Clouds
AVolumetricCloud* Clouds = FindOrSpawn();
// Optional shaping:
// if (auto* C = Clouds->GetVolumetricCloudComponent()) { C->LayerBottomAltitude = 2000.f; C->LayerHeight = 8000.f; }
// 4) Exponential Height Fog
AExponentialHeightFog* Fog = FindOrSpawn();
if (UExponentialHeightFogComponent* FogComp = Fog->GetComponent())
{
FogComp->SetMobility(EComponentMobility::Movable);
FogComp->FogDensity = 0.02f;
FogComp->FogHeightFalloff = 0.2f;
FogComp->bEnableVolumetricFog = true;
}
// 5) SkyLight (ambient + reflections)
ASkyLight* SkyLight = FindOrSpawn();
if (USkyLightComponent* SkyComp = SkyLight->GetLightComponent())
{
SkyComp->SetMobility(EComponentMobility::Movable);
SkyComp->bRealTimeCapture = true; // dynamic time-of-day; costlier but convenient
SkyComp->Intensity = 1.0f;
SkyLight->RecaptureSky(); // make sure it captures the current sky
}
}
“`
**How to use**
– Add this actor to any level (once), or spawn it from your GameMode on first load.
– It will find existing sky actors or spawn/configure them if missing.
– Tweak intensities/altitudes to taste; all the usual properties are accessible from the components shown.
If you prefer **design-time defaults**, subclass each (e.g., `AMyDirectionalLight`) and set properties in the constructor; then place those classes in your template map.