Skills

Place cameras within scenes, including CineCameraActor placement, composition principles, attachment, look-at targeting, and viewport pilot mode.

Move cameras through scenes using dolly, truck, boom, pan, tilt, roll, orbit, Steadicam, crane, jib, spline paths, and procedural shake.

Configure optical properties such as focal length, sensor size, aperture, depth of field, focus distance, and physical camera exposure.

Use Sequencer for cinematics, covering Level Sequences, actor tracks, keyframing, camera cuts, sub-sequences, and render settings.

Position actors and props for cinematic or interactive purposes, including stage marks, spatial relationships, sight lines, and Z-blocking.

Light scenes for cinematic and real-time rendering, covering three-point lighting, Lumen GI, light types, shadows, and sky atmosphere.

Apply and configure materials: PBR material model, Material Instances, parameter exposure, dynamic materials, and common surface looks.

Author material shader graphs: node-based visual programming for surface appearance, material expressions, texture sampling, and Substrate.

Render final output via Movie Render Queue: offline high-quality video/image output, anti-aliasing accumulation, and multi-pass rendering.

Post-process pipeline effects: Post Process Volumes, color grading, LUTs, bloom, ambient occlusion, tone mapping, and auto-exposure.

Nanite virtualized geometry: render extremely high-polygon meshes without traditional LOD authoring, Virtual Shadow Maps, and debugging tools.

Niagara particle system for VFX: Systems, Emitters, Modules, common patterns (fire, fog, smoke, sparks), and GPU/CPU simulation.

Color pipeline management: OpenColorIO, ACES/ACEScg, display LUTs, tone mapping, and VP color workflows.

Play back and blend character animations: Animation Blueprints, Montages, Blend Spaces, retargeting, and layered animation.

Control Rig node-based rigging: in-engine skeletal manipulation with FK, IK, full-body IK, retargeting, and Sequencer integration.

Motion Matching via Pose Search: data-driven animation selection replacing hand-authored state machines with automatic pose matching.

Import and configure MetaHuman characters: Quixel Bridge pipeline, LOD management, body/face configuration, and performance readiness.

Acquire and retarget third-party animation onto MetaHumans: Mixamo, Rokoko, ActorCore imports, IK Retargeter, and batch retargeting.

Build Pose Search databases for MetaHumans: retargeted third-party animation libraries turned into responsive motion systems.

Runtime procedural animation: IK foot placement, look-at, aim offset, physics-driven motion, and CCDIK/FABRIK solvers.

Create and edit Landscapes: heightmap import, sculpt tools, material layer painting, LOD configuration, and World Partition integration.

Populate environments with vegetation: foliage painting, procedural placement, Landscape Grass Types, Nanite foliage, and performance.

Water System plugin: oceans, rivers, lakes, and custom water bodies with physically-based rendering, landscape interaction, and buoyancy.

Dynamic weather and time-of-day: Sky Atmosphere, Volumetric Clouds, directional light, Exponential Height Fog, and Niagara effects.

Procedural Content Generation framework: graph-based rule-driven generation, point generation, filtering, mesh spawning, and landscape-aware generation.

Level streaming systems: World Partition, grid-based streaming, Data Layers, HLOD, streaming volumes, OFPA, and Level Instances.

Sky atmosphere, volumetric clouds, exponential height fog, sky lights, and time-of-day systems.

Landscape materials with layer blending, weight painting, grass types, and auto-material setups.

Level blockout with BSP brushes, greyboxing, blocking volumes, grid snapping, and player metrics.

Bake static lighting with Lightmass: lightmap UVs, build quality, portals, and GPU Lightmass.

Chaos physics engine: rigid body simulation, forces, constraints, ragdoll setup, and physics-driven gameplay elements.

Collision system: primitives, channels, presets, overlap events, blocking behavior, and line/shape traces for interaction detection.

Chaos Cloth simulation: cloth painting, collision bodies, wind interaction, constraint tuning, capes, skirts, curtains, and flags.

Chaos Vehicle system: physics-based vehicle simulation, wheel configuration, suspension tuning, drivetrain setup, and input binding.

Chaos Destruction: geometry collections, fracturing, field system actors, break events, and debris management.

Flight physics: Chaos Vehicle thrusters/aerofoils, FloatingPawnMovement, hover, VTOL, and aircraft controls.

Watercraft physics: UBuoyancyComponent, pontoons, wave response, rudder/propulsion, and water interaction.

Tracked vehicle physics: tank tread simulation, differential steering, suspension, and Chaos tracked config.

Create and modify Blueprints: visual scripting, class hierarchy, event graphs, functions, variables, and component architecture.

Enhanced Input System: Input Actions, Mapping Contexts, Modifiers, Triggers (hold, double-tap, chorded), and gamepad/keyboard/mouse/touch.

Gameplay Ability System (GAS): abilities, attributes, effects, and gameplay tags in a scalable, network-replicated, data-driven way.

Save/load system: persist game state to disk, SaveGame objects, serialization, save slots, autosave patterns, and data migration.

Dialogue systems: linear NPC speech to complex branching conversations with player choices, conditions, and consequences.

Inventory systems: item DataAssets, component patterns, equipment slots, stacking, crafting, and GAS integration.

Niagara Fluids plugin: GPU-accelerated real-time fluid simulation for gas, liquid (FLIP solver), and 2D shallow-water surface ripples.

Audio in Sequencer: audio tracks, dialogue alignment, music scoring, spatial audio, and MetaSounds/Sound Cue integration.

Facial animation capture: ARKit, MetaHuman Animator, Live Link streaming, runtime lip sync, and audio-driven lip sync systems.

Author custom Niagara modules: Scratch Pad, HLSL expressions, data interfaces, and module I/O.

Niagara mesh and ribbon rendering: mesh particles, orientation, material overrides, and ribbon trails.

MetaSound graph authoring: procedural audio synthesis, trigger/generator nodes, Builder API, and DSP.

Third-party audio: Wwise and FMOD plugin setup, bank management, RTPCs, and spatial audio.

Common UI plugin: input-method-agnostic UIs for keyboard/mouse, gamepad, and touch with focus management and activation layers.

UMG widget system: Widget Blueprints, visual designer, common widget types, layout panels, data binding, and widget animation.

C++ Slate UI framework: SWidget hierarchy, declarative syntax, style sets, editor tool panels, and FSlateApplication.

Game menu architecture: main menus, pause menus, settings screens, widget stacks, and menu flow.

Text localization pipeline: FText, string tables, LOCTEXT macros, .po files, and culture switching.

Multiplayer networking: server-authoritative replication, variable replication, RPCs, ownership, relevancy, and movement prediction.

Pixel Streaming: render on a server and stream interactive output to a web browser via WebRTC, signaling, quality tuning, and cloud deployment.

Server-side world streaming: replication graphs, net relevancy, cull distances, and World Partition server streaming.

Advanced networking: client-side prediction, server reconciliation, lag compensation, and custom net serialization.

Online platform services: Epic Online Services (EOS), sessions, matchmaking, leaderboards, and achievements.

Build and deploy dedicated servers: server targets, BuildCookRun, containerization, and cloud hosting.

Server-side data persistence: player data storage, database integration, cloud saves, and USaveGame networking.

Voice chat integration: VOIP setup, push-to-talk, proximity voice, voice channels, and team chat.

Data-driven design: Data Tables, Curve Tables, Curve Assets, Struct-based configuration, CSV import/export, and runtime data lookup.

Automate the editor with Python: unreal module API, asset manipulation, level automation, batch processing, and AgentUX integration.

AI navigation and behavior: NavMesh generation, AI Controllers, Behavior Trees, Blackboards, EQS, AI Perception, and crowd management.

Bridge C++ and Blueprint: UFUNCTION/UPROPERTY specifiers, delegates, function libraries, and struct/enum exposure.

Asset loading and management: soft references, async loading, StreamableManager, Asset Registry, and primary assets.

HTTP and web data: FHttpModule, REST API calls, JSON serialization, WebSocket clients, and async downloads.

UE Learning Agents plugin: reinforcement/imitation learning, training environments, ONNX inference, and policy networks.

Execute AI Assistant output via AgentUX: paste instructions from UE's AI Assistant and AgentUX parses, verifies, and executes them step by step with checkpoint approval.

Source control with UE5: Git with LFS, Perforce integration, OFPA, binary asset conflict resolution, and Blueprint diff/merge tools.

Package projects for distribution: standalone executables, content cooking, platform-specific settings, and release preparation.

Diagnose and resolve performance issues: stat commands, Unreal Insights, GPU/CPU bottleneck identification, and memory profiling.

Optimize rendering: draw call reduction, scalability groups, LOD tuning, instancing, and actor merging.

Package for mobile: Android SDK/NDK, iOS provisioning, texture compression, and mobile build configuration.

Package for consoles: platform SDK setup, TRC/XR requirements, platform INI overrides, and certification prep.

Publish to storefronts: Steamworks, Epic Games Store, achievements, DLC setup, and store page requirements.

Virtual Production ecosystem: real-time filmmaking with LED walls, camera tracking, and in-camera VFX (ICVFX) via nDisplay and Live Link.

nDisplay cluster configuration: nodes, viewports, ICVFX camera settings, sync policies, and LED wall setup.

Generate geometry at runtime: ProceduralMeshComponent, DynamicMeshComponent, vertices, UVs, and collision.

Execute PCG graphs at runtime: seed control, deterministic generation, streaming integration, and dynamic regeneration.

VR controller integration: motion controllers, OpenXR actions, hand tracking, haptic feedback, and HMD setup.

Mobile touch input: gesture recognition, virtual joysticks, touch interfaces, and screen region configuration.