跟读练习: Unreal Engine 5.8 - Experimental MCP Server Support Walkthrough | State of Unreal 2026 - 通过视频学习英语口语

Thanks, Simon.

Now, at times, making games can be hard,

expensive, and slow, where the gap between what you can imagine and what you can make is held back by technical overhead.

I don't know about you, but spending hours in a node graph trying to untangle

and understand what's going on just to change one thing is not my idea of creativity.

There has to be a better way to do this.

So that's what we've been working on, tools that enable you to build faster and iterate more.

Now, Unreal has been built on a simple idea, your source, your pipeline, your workflow.

Give developers complete control over the tools and get out of the way. That philosophy hasn't changed.

We're just applying it to large language models.

Now in 5.8, we've implemented an MCP server that acts as a bridge between Unreal and any model that you want.

For this presentation, we're going to be using Cloud Code.

But you can use Gemini, your own custom model, whatever you want.

Enabling the Unreal MCP is as simple as turning on the plugin, doing a bit of config, and connecting to the model of your choice.

And everything you're about to see today runs on that setup.

Now, these are still early days, and models will still do some really unpredictable things.

However, with this approach, we maintain the ability to go in and edit as you would any Unreal scene.

OK, let's see this in action.

On the left, we have Unreal Engine.

On the right is a terminal running Cloud Code.

You can see every message going back and forth.

Cloud Code is talking to Unreal through the MCP server, reading the scene, and taking actions directly inside the engine.

So let's start with something small, a modern living room.

We start by giving the model some context, what we want to build and whereabouts in the level.

And to make sure everyone can follow along, We're showing a summarized version of each prompt as we go.

But if you want the full details, you can still see that in the terminal window.

We're going to speed things up from here for presentation purposes, but everything you're seeing is real work happening inside the engine.

So you can ask for the basics, a sofa, a rug, and a coffee table.

Then fill it in with chairs, a lamp, and a side table.

Semantic Search, which is part of the 5.8 release, pulls assets from your library that fit that description.

And because this is unreal, we can also manually add a chair, describe it as a reading nook, and the model will furnish the room accordingly.

Every step here is a creative decision that you're making.

Models are good at broad iterations.

You're good at knowing exactly what you want.

Those same principles work whether you're furnishing a room or whether you want to scale up and build an entire city.

So let's take that same approach and build a city.

What characteristics each one has.

Highways cut through on your direction.

And from those, the road network starts to fill in.

Place them in the level.

Ask for a forest around the edge, and it can fill that in.

At every step, you're making the calls.

What do you end up with?

It's not a rendered image.

It's real geometry, real procedural content generation graphs that you can open, edit, and modify.

And this works for a whole team, too.

Other developers can work on their own sessions, building assets and dropping them straight into the city.

The road network adjusts, the blocks update, and the city absorbs it.

Different people, different sessions, and it all works together.

So how does all of this actually work?

With the MCP server as the bridge between Unreal and your model, it gives your model the ability to read your scene,

understand your assets, and make changes directly in the engine.

And because it's open, you're not locked into any particular model or workflow.

Now, while large language models are great at language and reasoning, they don't naturally think spatially.

Unreal does.

To help connect the two, we're giving you over 80 foundational procedural content generation building blocks,

a library of examples, and skills that encode specific Unreal workflows.

Now, this is experimental, and it's going to keep getting better.

This is where you come in.

Tell us what's working.

Tell us what's not.

That's how we're going to make this better.

Now that the city is built, we want to light it.

Getting lighting right on Unreal is a skill that means touching dozens of parameters that all need to work together.

Light balance, cloud materials, sky atmosphere, post-process.

That's a lot to know.

But by creating a dedicated lighting skill, You just describe what you want, and the model orchestrate it is.

Under the hood, it's adjusting all those settings in concert.

Then we can ask for overcast skies.

And this is a good example of where the model gets things wrong.

It misread the sky and tweaked the cloud material the wrong way.

You can see exactly what happened, correct it in the next prompt, and you're right back to where you want to be.

Because models also have real-world knowledge, You can just say Bogota at 9.30 in the morning.

And it will go and figure out the sun position, direction, temperature, and atmosphere that actually matches that.

And if you want to match something specific, you can take an image, so here we used one in Vancouver, and ask it to replicate that look.

It uses screenshots to assess and iterate until it gets there.

And everything is still editable.

Grab a road and move it, the city adjusts around it.

Ask it to make a building taller or more prominent in the scene, and it does that.

But then you can go in and modify any individual asset, making it exactly the way that you want it.

This isn't the generated image that you're stuck with.

It's a real scene in Unreal, and you control every part of it.

Flashing lamps, steam, and a sense of danger as the player gets close.

That normally means days of back and forth across multiple disciplines.

So here's what we did instead.

The warning lamp already has a material.

Let's say you want to add something to it.

You ask the model to read the existing graph, build the new logic, and insert it right where it needs to go.

You can then jump into the material instance editor and tweak the final values by hand.

Then you take a Niagara template and extend it, adding a single parameter that drives multiple emitters at once, giving you control over the whole effect in one place.

You build out the HUD through prompting and UMG.

Status display, danger meter, warning states.

Then blueprint logic ties it all together, a proximity trigger connected to the material, the Niagara system, and the HUD.

Walk in, and everything fires at once.

All right, so let's run it.

Lamps are off.

It's quiet.

She walks toward the site.

The lamps come on.

100

The steam starts rising.

101

She steps inside, lamps are flashing, steam's pouring in, and the site is erupting.

102

What we've shown here today would take months to build by hand.

103

But with the MCP server and Unreal, our artists were able to make all of this in days.

104

When you lower the technical friction, you can iterate more and make better games.

105

That's what we've built.

106

This is really just a starting point.

107

Bring your own primitives, your own examples, your own skills built around your pipelines.

108

The more your team puts in over time, the more useful it gets for everyone on the project.

109

We're shipping the MCP server, the PCG primitive plugin, and the skills we've developed as part of 5.8 today.

110

It's open and it's yours to extend.

111

Go download it, point your model at it, and see what you can do.

112

If you want to go deeper, we've got two chances to catch our tech talk here at Fest.

113

Come find us.

114

Now I'm gonna hand it over to Pat to talk about how some of what I've shown you

115

impacts linear content creation in the engine.

116

PAT TUBOCH, Thanks, Michael.

117

Hi, everyone.

118

My name is Pat Tuobach.

119

I've got a background in film and television.

120

For media and entertainment, the MCP plugin that Michael just showed you opens up a wide range of new connections to LLMs,

121

but also to image and video models like Nano Banana, GPT Image, Grok Imagine, Luma, Seed Dance, and many more.

122

Michael was telling you about tools in the present, and I'm going to cover tools for creating linear content

123

that are releasing early next year that give you control over these models.

124

The standard approach to using an image model is to start by crafting a text prompt.

125

In this case, I wrote a novel describing a fictional scene in Epic Motors, a 1950s gas station.

126

But in professional situations where you have to hit story points, match exact continuity, and deliver what your creative director wants,

127

you would typically communicate visually through sketches and pre-riffs.

128

Unreal is great for that.

129

So, to get started in Unreal, I scouted the derelict corridor scene from Quixel that's available on Fab,

130

which I quickly customized to look like the gas station layout I needed.

131

I worked in detail lighting mode since I was just using this for blocking to this stage.

132

I dropped in some of the appropriate assets from that map, shelving, a propane tank, a cabinet, and also made proxy shapes for the assets that I didn't have,

133

a long counter, more shelving, a cash register, and an ice chest.

134

Then I backed up and framed my camera view

135

and animated a boom down and a push in that I'd later use for my shot.

136

But before I tackled the full video creation, I had to create a single style frame, the visual reference of my scene.

137

To do that, I used the model to combine a depth pass plus the prompt novel I'd written before.

138

The depth conditions the models to understand the layout and the framing.

139

Here's how that works using our new tools in Unreal.

140

I asked ColladeCode, connected by our MCP plugin, to use Unreal's movie render graph to create a 4K image plus all the rest.

141

Asking for an Unreal render to create the image was a signal to ColladeCode

142

that I wanted to give my model my depth pass, but used the creative look described in my prompt.

143

I then fired off that request.

144

And while it was being generated, I inspected the graph that it made for the task.

145

Image models are hungry for helpful data and conditioning, and so I prepared a process that pulls valuable visual data from the Unreal scene and passes it to the image model,

146

in this case, Google's Nano Banana Pro.

147

Now, let's take a look at this image more closely.

148

You can see it matched the composition of my model.

149

I wanted another tire on the floor, but I didn't there to mask the tire.

150

I selected both the mask and the image, and with a predefined workflow, asked Claude Code to extract it, repair it, and mesh it using Tripo 3.1.

151

And then I double-checked that graph, and I supervised the work.

152

Now, of course, this is not a real-time process.

153

So after several minutes, I got my texture tire mesh.

154

I saved it to the content browser, where I then pulled in the tire and positioned it in 3D space.

155

And finally, I asked Cloud Code to add the tire to the image.

156

Let's take a look at that result.

157

So if we compare my UE passes with the tire in it, you can see that it put the new tire where I asked it to, and it made it look like a variation of the generated tire, not an exact amount in 3D.

158

I went browsing on FAB and found one of our junkyard car parts for mega scans.

159

I picked the specific fender piece that I wanted

160

that had a 1950s look modeled into it to leave less to the image model's imagination.

161

I asked Claude Code to add it to my image and make it look like it had been newly repainted.

162

And after another image processing step in banana, banana, that was done.

163

OK, now that I've produced my style frame, I was ready to go back to our new Unreal tools to generate a video of our scene.

164

And here's my shot camera move again.

165

If you recall, this is the move that I created at the beginning.

166

Over on the right, I ran a sequence render node that represents the depth over the entire range.

167

I'm going to use the same depth restyling process with the video that I did on the still image.

168

I supply the style frame I just generated to the video model as a first frame reference, and you can see that I added a cat, just hoping for a bit of life.

169

And then I set my video generation node to use CDance 2.0, set the resolution, added audio, and then I was off.

170

Once that process had run for several minutes, I had a video that looked like this.

171

So clearly, this is showing you that I can control the camera, but nobody controls a cat.

172

This is a different workflow that we've in parallel for more rapid concepting with diffusion and your viewport side by side.

173

What you're seeing here in this video is the UE viewport on the left

174

that was streaming to a local FluxKline image model on the right.

175

The local model result isn't temporarily coherent.

176

It was stamping a new image on every frame and only running a few frames a second, which is why it seems slower over there on the right.

177

But let me show you how intuitive it is to use.

178

I prompted for sunset lighting at first

179

and then decided to see what it would look like if there had just been a fire in this apartment.

180

And then I tried something more extreme, like being underwater at the bottom of a murky pond.

181

The real benefit you get here is being able to go back to the UE viewport, interact with the assets, and see them reposition through this new diffusion lens.

182

Not only that, but you can try more illustrated looks, like a charcoal drawing or even a watercolor painting.

183

As models get more capable and hardware improves, it's not hard to project this workflow forward to a time when diffusion is real-time and temporally consistent.

184

OK, let's look at some other examples of Unreal Engine scenes restyled by artists in the Engine using a variety of sources,

185

some of which are premium environment packs from our friends at KitBash 3D, and some of which are our own internal assets, including the city sample.

186

Starting from quality source assets leaves less room for interpretation by the models.

187

We think these new UI tools are a force multiplier

188

that will give artists more opportunities for creative iteration on their work alongside the real-time animation,

189

modeling, texturing, and virtual production tools that you've come to count on in Unreal Engine.

190

So this is where we're headed.

191

The MCP server that's enabling all this is experimental.

192

And what you're seeing here for image and video creation will be available early next year.

193

We're on this journey together, and we're aware that for these models to be truly useful, we need to focus on not just lowering technical complexity,

194

but also giving you full creative control over what you're making.

195

Thank you.

196

Thanks, Pat.

197

That was awesome.

什么是跟读法？

跟读法 (Shadowing) 是一种有科学依据的语言学习技巧，最初开发用于专业口译员的培训，并由多语言者Alexander Arguelles博士普及。这个方法简单而强大：您在听英语母语原声的同时立即大声重复——就像是一个延迟1-2秒紧跟说话者的影子。与被动听力或语法练习不同，跟读法强迫您的大脑和口腔肌肉同时处理并模仿真实的讲话模式。研究表明它能显着提高发音准确性，语调，节奏，连读，听力理解和口语流利度——使其成为雅思口语备考和真实英语交流最有效的方法之一。

跟读练习: Unreal Engine 5.8 - Experimental MCP Server Support Walkthrough | State of Unreal 2026 - 通过视频学习英语口语

视频背景：游戏开发背后的"技术对话"

5个实用口语短语，日常/雅思都能用

影子跟读分步指南：攻克技术类对话

什么是跟读法？