-
Notifications
You must be signed in to change notification settings - Fork 0
Home
This guide explains every setting in OneClickOptimizer in simple terms. Whether you're new to Unreal Engine or an experienced developer, you'll understand exactly what each setting does and when to use it.
Don't want to read everything? Here's what you need to know:
- First Time: Just click the "Quality" button - it works great for most projects
- Need More FPS: Click "Performance" button
- Taking Screenshots: Click "Cinematic" button
- Want to Customize: Read this guide and adjust settings
That's it! The plugin handles everything automatically.
Think of your game like a restaurant kitchen:
- Without optimization: Every dish is made from scratch, takes forever, uses all resources
- With optimization: Smart shortcuts, batch cooking, efficient use of resources
Optimization makes your game run faster (higher FPS) and use less memory (RAM/VRAM).
FPS = Frames Per Second = How smooth your game looks
- 30 FPS: Playable but not smooth
- 60 FPS: Smooth (target for most games)
- 120 FPS: Very smooth (high-end gaming)
Imagine the GPU (graphics card) as a chef:
- Each "draw call" = One order to cook something
- 1000 objects = 1000 orders = Chef is overwhelmed
- With optimization: Group similar orders = Chef is happy
Imagine you're in a city. You can see nearby buildings clearly, but buildings 10 miles away? You can't see them anyway, so why should the game render them?
Culling = Hiding objects that are too far away to see
What it does: Automatically hides objects based on their size and distance from camera.
Real-world example:
You're playing a game:
- Small rock 50 meters away: Hidden (you can't see it anyway)
- Large building 50 meters away: Still visible (you can see it)
- Small rock 5 meters away: Visible (you're close enough)
Performance impact: ⭐⭐⭐⭐⭐ HUGE (can double your FPS!)
Visual impact:
When to enable:
- ✅ Always (recommended for all projects)
- ✅ Open world games
- ✅ Large levels
- ✅ Performance issues
When to disable:
- ❌ Taking screenshots (want everything visible)
- ❌ Cinematic mode
- ❌ Very small levels (no performance benefit)
What it does: More aggressive culling - hides small objects even closer to camera.
Think of it like this:
- Normal culling: "Hide that rock if it's 50 meters away"
- Draw call optimization: "Hide that rock if it's 20 meters away"
Performance impact: ⭐⭐⭐⭐⭐ HUGE
Visual impact:
When to enable:
- ✅ Performance mode
- ✅ Low-end PC/console
- ✅ Battle royale games (many objects)
- ✅ Mobile games
When to disable:
- ❌ Quality/Cinematic mode
- ❌ Small detailed scenes
- ❌ Architectural visualization
The plugin automatically categorizes objects by size:
Tiny Objects (0-50cm):
- Examples: Pebbles, small props, debris
- Default hide distance: 500 units (5 meters)
- Adjustable: 200-1000 units
Small Objects (50cm-2m):
- Examples: Chairs, small furniture, props
- Default hide distance: 2000 units (20 meters)
- Adjustable: 1000-5000 units
Medium Objects (2m-5m):
- Examples: Cars, large furniture, trees
- Default hide distance: 5000 units (50 meters)
- Adjustable: 3000-10000 units
Large Objects (5m+):
- Examples: Buildings, large structures
- Default hide distance: 10000 units (100 meters)
- Adjustable: 5000-20000 units
How to adjust:
- Open Settings widget
- Find "Tiny/Small/Medium Objects Cull Distance"
- Lower number = More aggressive (hides sooner)
- Higher number = Less aggressive (hides later)
Tags are like labels you put on objects. Think of them as sticky notes that say "Don't optimize me!"
Default: "NoOptimize"
What it does: Objects with this tag are completely skipped by the plugin.
How to use:
Method 1: In Editor (Actor)
- Select your actor in the level
- Look at Details panel
- Find "Tags" section
- Click "+" to add new tag
- Type "NoOptimize"
- Done! This actor won't be optimized
Method 2: In Editor (Component)
- Select your actor
- In Details panel, find the component (e.g., Static Mesh Component)
- Scroll to "Tags" section under "Component Tags"
- Add "NoOptimize"
Method 3: In Blueprint
// Add tag to actor
Actor Tags -> Add "NoOptimize"
// Add tag to component
Component Tags -> Add "NoOptimize"
When to use:
- ✅ Player character (always visible, needs to be perfect)
- ✅ Important hero assets (main building, key objects)
- ✅ Cinematic objects (used in cutscenes)
- ✅ Already optimized objects (don't optimize twice)
- ✅ Interactive objects (doors, buttons, etc.)
Example scenario:
You have a beautiful hero building that you spent hours optimizing manually.
Add "NoOptimize" tag so the plugin doesn't change your work!
Default: "NoDrawCallOptimization"
What it does: Skips ONLY the aggressive culling, but still applies other optimizations.
Difference from NoOptimize:
NoOptimize: Skips EVERYTHING (culling, LOD, lightmap, etc.)
NoDrawCallOptimization: Skips ONLY aggressive culling
When to use:
- ✅ Objects that need to be visible from far away
- ✅ Landmarks (mountains, towers)
- ✅ Skyline buildings
- ✅ Important background objects
Example:
You have a castle on a hill that players should always see.
Add "NoDrawCallOptimization" tag.
Result: Castle stays visible, but still gets LOD and lightmap optimization.
Imagine taking a photo of how light falls on an object, then using that photo instead of calculating lighting in real-time.
Lightmap = Pre-calculated lighting saved as a texture
Benefits:
- Much faster than real-time lighting
- Looks great
- Used in most games
Problem:
- Takes memory (RAM/VRAM)
- Small objects don't need high-resolution lightmaps
What it does: Automatically assigns appropriate lightmap resolution based on object size.
How it works:
Tiny object (rock): 4x4 pixels lightmap
Small object (chair): 16x16 pixels lightmap
Medium object (car): 32x32 pixels lightmap
Large object (building): 64x64 pixels lightmap
Why this matters:
Without optimization:
100 small rocks, each with 64x64 lightmap:
100 × 64 × 64 = 409,600 pixels = 1.6 MB memory
With optimization:
100 small rocks, each with 4x4 lightmap:
100 × 4 × 4 = 1,600 pixels = 0.006 MB memory
Memory saved: 99.6%!
Performance impact: ⭐⭐⭐⭐ HIGH (memory savings)
Visual impact:
When to enable:
- ✅ Always (recommended)
- ✅ Memory issues
- ✅ Many small objects
- ✅ Mobile games
When to disable:
- ❌ Architectural visualization (need perfect lighting)
- ❌ Very few objects (no benefit)
Tiny Objects Lightmap Resolution
- Default: 4 (minimum)
- Range: 4-16
- Recommendation: Keep at 4
Small Objects Lightmap Resolution
- Default: 16
- Range: 8-32
- Recommendation: 16 for most games
Medium Objects Lightmap Resolution
- Default: 32
- Range: 16-64
- Recommendation: 32 for most games
Large Objects Lightmap Resolution
- Default: 64
- Range: 32-128
- Recommendation: 64 for most games, 128 for hero assets
How to choose:
Lower resolution = Less memory, slightly worse lighting
Higher resolution = More memory, better lighting
For most games: Use defaults!
Think of it as a 3D map that tells the game "how far is the nearest surface?"
Used for:
- Distance Field Ambient Occlusion (DFAO) - Soft shadows in corners
- Distance Field Shadows - Soft shadows from sun
- Ray Traced effects
Visual example:
Without DFAO: Corners look flat
With DFAO: Corners have soft shadows, looks more realistic
What it does: Creates distance field data for each mesh.
Performance impact:
When to enable:
- ✅ Using Distance Field Ambient Occlusion
- ✅ Using Distance Field Shadows
- ✅ Ray tracing
- ✅ High-end PC/console games
When to disable:
- ❌ Mobile games (not supported)
- ❌ Low-end PC
- ❌ Not using DFAO or DF Shadows
- ❌ Memory constrained
How to check if you need it:
- Open your Post Process Volume
- Look for "Distance Field Ambient Occlusion"
- If it's enabled → Enable this setting
- If it's disabled → Disable this setting
Super small shadows where objects touch each other.
Examples:
- Shadow where your foot touches the ground
- Shadow where a book sits on a table
- Shadow where an object touches a wall
Why they matter:
- Make objects look "grounded"
- Add realism
- But expensive to calculate
What it does: Optimizes contact shadow settings.
What it does: Turns off contact shadows for tiny objects.
Logic:
Tiny rock: Contact shadow is so small you can't see it anyway
Large car: Contact shadow is visible and important
Performance impact: ⭐⭐⭐ MODERATE
Visual impact:
When to enable:
- ✅ Performance mode
- ✅ Many small objects
- ✅ Low-end hardware
When to disable:
- ❌ Cinematic mode
- ❌ Close-up shots
- ❌ Architectural visualization
Every object has an invisible box around it. The game uses this box to decide when to hide the object.
Problem:
Small object with big bounds = Stays visible too long = Wastes performance
What it does: Shrinks the invisible box for small objects.
Result:
Before: Small rock with big box = Visible from far away
After: Small rock with small box = Hidden sooner = Better performance
Performance impact: ⭐⭐ LOW
Visual impact:
Recommendation: Always enable (no downside)
LOD = Level of Detail
How it works:
Close to camera: High detail mesh (10,000 triangles)
Medium distance: Medium detail mesh (2,500 triangles)
Far from camera: Low detail mesh (500 triangles)
Very far: Lowest detail mesh (100 triangles)
Why it matters:
Without LOD: Game renders 10,000 triangles even when object is far away
With LOD: Game renders 100 triangles when far = 100x faster!
What it does: Adjusts when LOD transitions happen.
Performance impact: ⭐⭐⭐⭐ HIGH
Visual impact:
Recommendation: Always enable
Default: -1 (automatic)
What it does: Forces all objects to use a specific LOD level.
Values:
- -1: Automatic (recommended)
- 0: Highest quality (all objects use best mesh)
- 1: Medium quality
- 2: Low quality
- 3: Lowest quality
When to use:
Testing performance: Set to 2 or 3 to see maximum FPS
Mobile preview: Set to 2
Normal gameplay: Keep at -1
Warning: Don't use in final game! Only for testing.
What it does: Removes mesh data from CPU memory (RAM).
Technical explanation:
Normally: Mesh data stored in both CPU (RAM) and GPU (VRAM)
With this enabled: Mesh data only in GPU (VRAM)
Memory savings:
1000 meshes, 1MB each:
Without: 1000MB (CPU) + 1000MB (GPU) = 2000MB total
With: 0MB (CPU) + 1000MB (GPU) = 1000MB total
Saved: 50%!
Performance impact: ⭐⭐⭐⭐ HIGH (memory)
Visual impact:
When to enable:
- ✅ Always (recommended for most games)
- ✅ Memory issues
- ✅ Mobile games
- ✅ Console games
When to disable:
- ❌ Using procedural mesh generation
- ❌ Runtime mesh modification
- ❌ Reading mesh data in Blueprint/C++
- ❌ Some physics simulations
How to check if you need CPU access:
Do you use these Blueprint nodes?
- Get Vertex Position
- Get Triangle Count
- Modify Mesh at Runtime
If NO → Enable this setting
If YES → Disable this setting
Imagine you have 1000 identical trees in your level.
Without instancing:
1000 separate trees
1000 draw calls (GPU has to draw 1000 times)
1000x memory usage
Result: Game runs at 20 FPS
With instancing:
1 "master" tree
1000 "instances" (copies)
1 draw call (GPU draws once, copies 1000 times)
1x memory + tiny instance data
Result: Game runs at 200 FPS!
This is MAGIC! 10x performance boost!
Default: Disabled (off)
What it does: Automatically groups identical meshes into instances.
How it works:
1. Plugin scans your level
2. Finds all identical meshes (same mesh, same material)
3. Groups them together
4. Creates one "ISM Manager" actor
5. Hides original meshes
6. Shows instances instead
Performance impact: ⭐⭐⭐⭐⭐ MASSIVE (10x boost!)
Visual impact:
When to enable:
- ✅ Many identical objects (trees, rocks, props)
- ✅ Foliage
- ✅ Repeated architecture
- ✅ Performance issues
When to disable:
- ❌ All objects are unique
- ❌ Objects need to move/animate individually
- ❌ Interactive objects (doors, buttons)
- ❌ Objects with unique properties
Important notes:
- Only works on IDENTICAL meshes
- Meshes must have same material
- Meshes must be static (not moving)
Default: 3
What it does: Minimum number of identical meshes needed to create an instance.
Example:
Min count = 3:
- 2 identical trees: No instancing (not enough)
- 3 identical trees: Instancing created!
- 100 identical trees: Instancing created!
How to adjust:
Lower (2): More aggressive instancing
Higher (5): Less aggressive instancing
Recommendation: Keep at 3
What it does: Uses advanced instancing with automatic culling.
ISM vs HISM:
ISM (Instanced Static Mesh):
- Simple
- All instances always rendered
- Good for: Small areas, few instances
- Example: 100 trees in a small park
HISM (Hierarchical Instanced Static Mesh):
- Advanced
- Far instances automatically hidden
- Good for: Large areas, many instances
- Example: 10,000 trees in open world
Performance comparison:
1000 trees in open world:
ISM: All 1000 rendered = 50 FPS
HISM: Only nearby 200 rendered = 120 FPS
When to use HISM:
- ✅ Open world games
- ✅ Large levels
- ✅ Thousands of instances
- ✅ Spread over large area
When to use ISM:
- ✅ Small levels
- ✅ Hundreds of instances
- ✅ Concentrated in small area
- ✅ All instances usually visible
Recommendation: Enable HISM for most games
Default: 5000 units (50 meters)
What it does: Distance where HISM starts hiding far instances.
How it works:
0-5000 units: All instances visible
5000-10000 units: Gradual fade out
10000+ units: All instances hidden
Default: 10000 units (100 meters)
What it does: Distance where all instances are hidden.
How to adjust:
Smaller values = More aggressive (better performance, less visible)
Larger values = Less aggressive (worse performance, more visible)
Open world: 10000-20000
Small level: 5000-10000
VSM = Unreal Engine 5's new shadow system
Old shadow system:
- Fixed resolution
- Blurry shadows
- Performance issues with many lights
Virtual Shadow Maps:
- Dynamic resolution
- Sharp shadows
- Works great with Nanite
- Next-gen quality
Visual difference:
Old: Shadows look pixelated up close
VSM: Shadows look sharp even up close
What it does: Enables VSM for your project.
IMPORTANT: Plugin automatically checks Nanite usage!
How it works:
Plugin scans your level:
- Less than 50% Nanite meshes: VSM disabled (would be slow)
- 50-80% Nanite meshes: VSM enabled with warning
- More than 80% Nanite meshes: VSM enabled (optimal)
Why this matters:
VSM without Nanite = Very slow (20ms+ per frame)
VSM with Nanite = Very fast (2-5ms per frame)
Performance impact:
- With Nanite: ⭐⭐⭐⭐ GOOD
- Without Nanite: ❌❌❌ TERRIBLE
Visual impact: ⭐⭐⭐⭐⭐ AMAZING
When to enable:
- ✅ Using Nanite (most meshes are Nanite)
- ✅ High-end PC/console
- ✅ Next-gen graphics
- ✅ UE 5.1+
When to disable:
- ❌ Not using Nanite
- ❌ Low-end hardware
- ❌ Mobile
- ❌ UE 5.0 (not available)
How to check if you should use VSM:
- Look at your meshes
- Are most of them Nanite-enabled?
- If YES → Enable VSM
- If NO → Disable VSM
Default: 4096
What it does: Quality of VSM shadows.
Values:
- 2048: Lower quality, better performance
- 4096: Balanced (recommended)
- 8192: Higher quality, worse performance
Recommendation: Keep at 4096 unless you have specific needs
Lumen = Unreal Engine 5's real-time lighting system
Old lighting:
- Pre-baked (calculated once, never changes)
- Moving lights don't work well
- Time of day changes require rebaking
Lumen:
- Real-time (calculates every frame)
- Moving lights work perfectly
- Time of day changes work automatically
- Looks amazing!
Visual example:
You move a light:
Old system: Lighting doesn't update
Lumen: Lighting updates in real-time!
What it does: Optimizes Lumen settings for better performance.
Performance impact: ⭐⭐⭐ MODERATE Visual impact: ⭐⭐⭐⭐⭐ AMAZING
When to enable:
- ✅ Using Lumen
- ✅ UE 5.0+
- ✅ Dynamic lighting
- ✅ High-end hardware
When to disable:
- ❌ Not using Lumen
- ❌ Low-end hardware
- ❌ Mobile
- ❌ Using baked lighting
Default: 20000 units (200 meters)
What it does: How far Lumen calculates lighting.
How it works:
Small value (10000): Lumen only calculates nearby lighting
Large value (50000): Lumen calculates far away lighting
Performance impact:
10000: Fast, but far objects don't get GI
20000: Balanced (recommended)
50000: Slow, but everything gets GI
Recommendation:
- Small levels: 10000-15000
- Medium levels: 20000 (default)
- Large open world: 30000-50000
Default: 1.0
What it does: Level of detail in Lumen calculations.
Values:
- 0.5: Lower detail, better performance
- 1.0: Normal detail (recommended)
- 2.0: Higher detail, worse performance
Visual difference:
0.5: Lighting is slightly less accurate
1.0: Balanced
2.0: Very accurate lighting
Recommendation: Keep at 1.0 unless you need extreme quality
Default: 1.0
What it does: Quality of final lighting calculation.
Values:
- 0.5: Faster, slightly noisier
- 1.0: Balanced (recommended)
- 2.0: Slower, cleaner
Recommendation: Keep at 1.0 for gameplay, use 2.0 for cinematics
What it does: Optimizes texture streaming.
Default: 3000 MB
What is texture streaming?
Imagine you have 10GB of textures in your game. Your GPU only has 8GB VRAM. What happens?
Without streaming:
Game tries to load all 10GB
GPU runs out of memory
Game crashes or looks terrible
With streaming:
Game loads only what you can see (3GB)
As you move, old textures unload, new textures load
GPU never runs out of memory
Game runs smoothly!
Pool size = How much texture memory to use
How to choose:
Low-end PC (4GB VRAM): 1000-1500 MB
Mid-range PC (6-8GB VRAM): 2000-3000 MB
High-end PC (10GB+ VRAM): 3000-4000 MB
Performance impact: ⭐⭐⭐⭐ HIGH
Visual impact:
Signs pool is too small:
- Textures look blurry
- Textures "pop" in (suddenly become sharp)
- Texture streaming warnings in log
Signs pool is too large:
- Game uses too much VRAM
- Other applications slow down
- System becomes unstable
Recommendation:
- Start with 3000 MB
- Play your game
- If textures look blurry → Increase to 4000 MB
- If game uses too much memory → Decrease to 2000 MB
WPO = World Position Offset
What it does: Moves vertices in the material (shader).
Examples:
- Grass/trees swaying in wind
- Flags waving
- Water rippling
- Cloth simulation
The problem:
WPO is calculated for EVERY vertex
Far away tree with 10,000 vertices = 10,000 calculations
You can't even see the tree moving from far away!
Result: Wasting performance
What it does: Turns off WPO for far away objects.
Performance impact: ⭐⭐⭐⭐⭐ MASSIVE (10x boost!)
Visual impact:
Real-world results:
Before: Shadow rendering 20ms per frame
After: Shadow rendering 2ms per frame
Improvement: 10x faster!
Community quote:
"Specifying WPO Disable Distance gives HUGE performance difference for Nanite and VSM."
When to enable:
- ✅ ALWAYS (if using WPO)
- ✅ Foliage with wind
- ✅ Animated materials
- ✅ Nanite + VSM
When to disable:
- ❌ Not using WPO
- ❌ Cinematic close-ups (want to see animation)
Default: 5000 units (50 meters)
What it does: Distance where WPO turns off.
Preset values:
- Performance: 3000 (aggressive)
- Quality: 5000 (balanced)
- Cinematic: 10000 (conservative)
How to choose:
Smaller value = Better performance, animation stops sooner
Larger value = Worse performance, animation visible longer
Recommendation: 5000 for most games
Presets are pre-configured settings for different scenarios. Think of them as "profiles."
Target: Maximum FPS, low-end hardware
Best for:
- Mobile games
- Low-end PC
- Battle royale (many objects)
- Competitive multiplayer
Settings:
- Aggressive culling (objects disappear sooner)
- Low lightmap resolution
- Aggressive LOD (lower quality at distance)
- ISM/HISM enabled
- WPO disable at 3000 units
Expected results:
Before: 30-40 FPS
After: 60-80 FPS
Improvement: 2x FPS!
Visual quality: Good (optimized but still looks nice)
Target: Balanced performance and quality
Best for:
- Most PC games
- Console games
- General use
- First playthrough
Settings:
- Balanced culling
- Medium lightmap resolution
- Balanced LOD
- ISM/HISM optional
- WPO disable at 5000 units
Expected results:
Before: 40-50 FPS
After: 60-90 FPS
Improvement: 1.5-2x FPS
Visual quality: Excellent (hard to tell from unoptimized)
Recommendation: Start here! Works great for 90% of projects.
Target: Maximum quality, screenshots, trailers
Best for:
- Taking screenshots
- Recording trailers
- Cinematic sequences
- Architectural visualization
- High-end PC showcase
Settings:
- Conservative culling (objects stay visible longer)
- High lightmap resolution
- Conservative LOD (high quality at distance)
- ISM/HISM disabled
- WPO disable at 10000 units
Expected results:
FPS: May be lower than Quality preset
Visual quality: Maximum
When to use:
- Taking screenshots
- Recording video
- Showing off graphics
- Final polish
When NOT to use:
- Normal gameplay (too slow)
- Low-end hardware (will struggle)
| Setting | Performance Impact | Visual Impact | Recommended |
|---|---|---|---|
| Culling Distance | ⭐⭐⭐⭐⭐ | ✅ Always ON | |
| Draw Call Opt | ⭐⭐⭐⭐⭐ | ✅ Performance mode | |
| Lightmap Opt | ⭐⭐⭐⭐ | ✅ Always ON | |
| Distance Field | ⭐⭐⭐⭐ | ||
| Contact Shadow | ⭐⭐⭐ | ✅ Always ON | |
| CPU Access OFF | ⭐⭐⭐⭐ | ✅ Usually ON | |
| ISM/HISM | ⭐⭐⭐⭐⭐ | ||
| VSM | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | |
| Lumen | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ✅ UE5 projects |
| WPO Disable | ⭐⭐⭐⭐⭐ | ✅ If using WPO |
- Install OneClickOptimizer plugin
- Restart Unreal Engine
- Open your project
- Look for "OneClick Optimization" button in toolbar
- Click "Quality" button
- Wait 10-30 seconds
- Done! Your project is optimized!
- Press ` (tilde key) to open console
- Type:
stat fps - Look at FPS number
- Compare before/after
Expected improvement:
- Small project: 20-50% FPS boost
- Medium project: 50-100% FPS boost
- Large project: 100-200% FPS boost
If FPS is still low:
- Click "Performance" button instead
- Open Settings widget
- Enable "Draw Call Optimization"
- Enable "ISM/HISM" (if you have many duplicate objects)
If quality looks worse:
- Click "Quality" button
- Open Settings widget
- Increase lightmap resolutions
- Increase cull distances
- Open Settings widget (click dropdown → Settings)
- Read this guide
- Adjust settings based on your needs
- Test and iterate
Q: Will this break my project? A: No! The plugin has a "Restore" button that undoes everything.
Q: Can I undo optimization? A: Yes! Click the "Restore" button or press Ctrl+Z.
Q: Which preset should I use? A: Start with "Quality" - it works great for most projects.
Q: My FPS didn't improve much, why? A: Your bottleneck might be elsewhere (CPU, GPU, code). Try "Performance" preset.
Q: Some objects disappeared, help! A: They're just hidden by culling. Increase cull distances in Settings.
Q: Can I use this with Nanite? A: Yes! The plugin works great with Nanite and even enables VSM automatically.
Q: Does this work on mobile? A: Yes, but disable Nanite, VSM, and Lumen features (not supported on mobile).
Q: How often should I optimize? A: After adding new objects or making major changes to your level.
Q: Can I optimize specific objects only? A: Yes! Add "NoOptimize" tag to objects you want to skip.
Problem: FPS didn't improve
- Solution: Try "Performance" preset
- Check if bottleneck is CPU (not GPU)
- Enable ISM/HISM if you have many duplicates
Problem: Objects disappearing too soon
- Solution: Increase cull distances in Settings
- Or add "NoDrawCallOptimization" tag to important objects
Problem: Textures look blurry
- Solution: Increase "Texture Streaming Pool Size"
- Check your GPU VRAM usage
Problem: Shadows look bad
- Solution: Disable "Contact Shadow Optimization"
- Or use Cinematic preset
Problem: Plugin not showing in toolbar
- Solution: Restart Unreal Engine
- Check if plugin is enabled in Edit → Plugins
Need help? Here's what to do:
- Read this guide - Most questions are answered here
- Check FAQ section - Common issues covered
- Try different presets - Quality → Performance → Cinematic
- Use Restore button - If something goes wrong
- Contact support - If still stuck
Congratulations! You now understand every setting in OneClickOptimizer.
Remember:
- Start with "Quality" preset
- Adjust settings based on your needs
- Test and iterate
- Use "Restore" if something goes wrong
Most important:
- You don't need to understand everything
- The defaults work great
- Just click "Quality" and enjoy better performance!
Version: 2.4 Last Updated: February 2026 Plugin: OneClickOptimizer Support: Available on Fab Marketplace
Thank you for using OneClickOptimizer! 🚀