SJOERD DE JONG: Hello,
and welcome, everyone. My name is Sjoerd De Jong. And in this video,
we're going to dive into the brand new water
features of Unreal Engine 4.26. I will walk you
through how easy it is to quickly get an ocean,
a lake, and a river set up, as well as dipping
our toes into some of the more specific
or advanced capabilities of our amazing new Water System. So we're going to start off
with the intro and the basics-- so essentially,
how to set up a basic body of water. What is it dependent on? Does it depend on the landscape,
and so forth. And once we've
gone through that, we're going to look at some
of the important settings and properties,
things like post processing that gets activated automatically
when you go underwater. We're going to go
forward by then taking a look at the overall
architecture of how the Water feature in the
engine has been done. So you get a
deeper understanding of how everything
ties together-- the different components,
the different actors, what it actually does behind the scenes,
that kind of thing. And then we're going to go
back to the example scene. And we're going to take a
look at a couple of more deeper features. They're still going to
be near the surface, but things like, for example,
how to cut a hole in the water, how to make a larger
wave like a mega wave, how to make things float
on the water, and so on. So a bit more advanced
use and some examples of how the rest of the engine
can tap into the Water System. And then finally,
we're going to wrap up and talk about performance. So exactly where is the
performance cost with water? What are some of the
CVars you can use? And finally, what are we
planning to do in the future? Well, let's get started. So in a few minutes, we're going
to move over to the real scene. And this is the real scene
that we're going to work with. So over the last
two or three months, I've built this big scene
with a lighthouse and so on. So that's going to be the
scene we're going to work in. We're going to first off,
however, start with a very basic level,
just to go through the basics
in a very clear, very clean and simple level so
it isn't too convoluted or too many settings, and actors,
and things going on. But we'll get to this
scene in a few minutes. And before we go there,
I'd also just like to highlight that we're using
Quixel Megascans, especially for the ground
and terrain textures. A lot of Marketplace
assets-- so thank you to Polypusher Studios,
Nature Manufacturer, George Shachnev, IndieG, 60fps, Eyosido Software,
and Project Nature. I'm using content
from all of them. And also a big thanks to
the Unreal Engine engineering team in general,
but in particular, Kevin Ortegren, Jonathan Bard, Ryan Brucks,
and Roey Boresteinas, who are the engineers
who have been working-- and Ryan is the
technical artist-- who has been working on
the Water as a feature that we're going
to talk about here. But let's get started. So in terms of intro and basics,
we're going to start off very,
very simple by using this simple,
basic little island. It's very gray. It's basically a gray box level. We've got a nice cloud setup
going on, a nice atmosphere. But we would like to
have an ocean added to this particular scene. Now, the first thing to note
is that in its current iteration-- and Water is,
just as we pointed out, still an experimental feature. So it's very work-in-progress. But in its current state,
it is very dependent on the landscape. That's the topic we're going
to discuss all the way at the end of this video as well. But it requires a landscape. So we have a landscape here. And then the next
thing it requires is that Enable
Edit Layers has been enabled on that landscape. So I've done that already. By default, this is off. But I've already enabled it. And then we're good to go. So essentially,
from that point onward, water is as simple as looking
for Water in the Place Actor panels. And this does, by the way,
require you to enable Water as a plugin. So it's a plugin. Enable the Water plugin. Look for Water. And you'll see the different
Water types show up. So I'm going to start
off with an ocean. I'm going to drag the ocean in. You can see there's a
spline associated with it. And again,
we'll explain that later too. It's because of landmass. You drag it in,
and you have an ocean. You can see you
immediately get the water. You get some nice waves. Everything is there. In fact,
you could go underwater. It looks underwatery,
underwater. And that's essentially it.
So it's as simple as click and drag, and you're good to go. Now, in the middle,
we have this ocean actor. You can it's a little bit
weird with the landscape because it carves it out. So I'm going to lower
it a little bit until it kind of matches the elevation
of the existing landscape. And then I'd like to set
one of these settings to falloff-- not to angle,
but to width. It gives a smoother falloff. But that's basically it. Now we can go the next step. And we can add a lake to the
middle of the island over here. So in this relatively flat area,
I'm going to add a lake. So I'm dragging the lake in-- same thing, just drag it in. Click there. It has a spline associated
from the Landmass system. And it carves into
the landscape. So I'm going to make
it a little bit smaller. And we can do the same
with the island, by the way. I left the spline
of the island as is. But you can always
modify the spline. You can right-click it. You can add points to it. You can change how it curves,
et cetera, et cetera, et cetera. So we can do
something like that. Similarly, here,
I'd like to set the angle to width. It makes for a smoother falloff. And what you have is a simple,
little lake. It works the same way. You've got waves in it. You can go underwater as well. Next up are rivers. And they work in pretty
much exactly the same way. So I'm going to drag a river in. I'm going to connect
the lake to the ocean, roughly around this point over here,
direct it in. I'm going to have to
move these points over. Rotate him a little bit. In fact, I'm going to
rotate the first point a bit as well to be correct,
or maybe not. I can leave that. I'm going to drag it a bit
more deeper into the lake. I think that final
point up there-- connect that to the ocean. And as you'll see over here,
it gets a little bit strange. It's not really how water
would behave in a real world. So let's make sure it matches
the height of the ocean. So that's roughly there. Let's take this point over
here as well and bring it down. So we'll end up with
something like so. And that's the basic setup. Now, the water will
automatically blend together. You can see you
automatically blend from the lake to the river. The river flows in the
direction of the spline and will then blend with
the ocean at the other end. You can always blend
multiple rivers together so you have another arm, another
branch of the river going over here and reconnecting
with the river. It'll be seamless. And in fact,
you can control the river by working with
the spline points-- not just by moving the
spline points in the viewport, but also by looking
at the settings where it says here, Depth,
River Width, and Velocity. And obviously, if you change this,
you get a thinner river. Obviously,
if you change the velocity, it would actually
start to flow faster. So that's the control
you have at the moment. So let's take the
next step forward. Let's take a look at some
of the important settings, how to control the waves
and how post processing comes into play here. When you look at
the oceans-- let's select the ocean over here. So these are some of
the properties we have. Without going through each
and every single property. Essentially,
the Terrain section is how the spline affects and
curves into the landscape. So you're free to
experiment with this. And other than that,
an important one here-- I'll just make this
a little bit wider-- is Water Material. Now, when we talk about
the architecture of the system, I'm going to talk about
how it's using material and what's being
done in the material. But essentially,
you can change the material there. And you can change
Underwater Post Processing, which we'll talk
about in a second as well, and here as well. These are the two most
important ones as well as the Wave Assets over here. Before we go to the waves,
I just want to highlight
this setting here. Wave Attenuation Water Depth-- this is essentially how much it
needs to flatten the waves when it comes near the shore. So dependent on the depth
of the surface to the ground underneath, it's going to
start to flatten the waves. So you can see that over
here where the waves-- you've got proper waves there. You no longer have any
waves near the shore. That is that setting over there. If we lower that, you're going
to get waves near the shore. But then that's going
to go wrong a little bit. So you're welcome to-- you
should definitely experiment a bit with that value. But that's what that does. But the waves-- so the waves
are based on either an asset, or you can change it to
actually being generated in the properties over here. So if we change it
from an Asset Reference to simply Gerstner Water Waves, I will get the exact same
thing as is in the asset, but we'll get it over here. So we can easily change
all of these properties that control the waves. So we can say, for example,
if you'd like to have more waves, and the complexity goes up. OK. I believe, if I'm correct,
we support up to 100 waves. So you're welcome, again,
to experiment with that. You can change the Minimum
and Maximum Wavelengths, essentially the
size of the waves. And the Minimum and
Maximum Amplitude is essentially the
size of the waves in the in vertical direction. So essentially, how steep
and aggressive are the waves? We have the
Dominant Wind direction and how much it's mixing. Right now,
it's all mixing kind of together. If you reduce Direction
Angular Spread, you're going to get all of
the waves moving more in the single direction. And you can experiment a
little bit with the steepness and see if you can
soften it out a bit. But again, these things
can either be set over here, or they can be made an asset. And I've made an asset
over here somewhere. And see? This one is an asset. It's the waves
saved as an asset. If I open that up,
you get the exact same thing, but as an asset. Cool. But that's basically it. This is how easy
and how fast it is to get a really nice ocean
and water surface going with these new features. But Unreal wouldn't
be Unreal if you wouldn't be able to go much
further than just that, right? If you wouldn't be able to tap
into the power of the system and modify it as you see fit,
make it adjustable for your specific environment
or your usage case, do all kinds of fun stuff
with it-- for example, make a Niagara particle
that reads the waves. So those are all the things
we want to look at in a second once we've talked
about the architecture. And by the way,
before I forget, indeed, it is also switching to a
post process material. That is a post process material
that is specified on the ocean. And it's also specified on the
lake and the river, by the way. You can set different ones. It will automatically
detect when you go underneath
the surface and enable this post process material. So it's a standard
post process material. But the interesting part
here is that it automatically enables it. And it also automatically
tries to blend it as you cross
into the water line. It doesn't do it 100%
accurate just yet. Again,
it's an experimental feature. But it's interesting to note. So let's move forward by
talking a little bit about how this works beneath the
surface so you better understand the system. Because it's really quite
interesting, what it does. So first of all, you need to
understand it's using Landmass. Now, Landmass was a plugin
that we released a while back. And essentially, what Landmass
does is it allows you to modify a heightmap-- the landscape-- to use a Blueprint and splines. So essentially, you would
be able to draw a spline that's the shape of a mountain. And it would generate a
mountain from that shape. And then you would be able
to move that mountain around on the landscape by moving
the spline, and the whole actor, the Blueprint around. You would be able to
copy/paste it and so on. So the Water System
right now is using that same Landmass
feature to draw islands, and to draw the lakes,
and to draw the rivers like you've just seen, using splines. So that's what's underneath it. That also brings
in a few limitations. It makes it really powerful
to very quickly add rivers and lakes, et cetera,
like you've just seen. It also brings in
a few limitations we're going to discuss later. Now, once you drag in
an ocean actor or similar, it's going to actually
spawn two additional things in the background. It's going to spawn a
WaterBrushManager. And it's going to
spawn a water mesh. And you can see there's also,
here in the scene-- if you look in the
World Outliner, we can see that it
has actually made-- because here is the lake,
the ocean, and the river, this is what we've made-- that it made a
Landscape_WaterBrushManager and then it's made
a WaterMeshActor. Now,
the WaterBrushManager is essentially capturing information
about the world and passing that on
to the water mesh that's about to be generated. So this is going to capture
the heightmap of the landscape and a few other things. It's going to generate
render targets from that. You can see it's showing the
render targets it generates. So it generates all of this. And then using the information
that is stored in these render targets-- and this is all happening
in the background, but that's how
the system works-- the water mesh, which is
the actual water surface itself-- because the ocean is not
actually the water surface, that is merely telling in
the WaterBrushManager what it's doing and
what it would like to do. And then the WaterBrushManager
is telling the WaterMeshActor how to render itself. The WaterMeshActor is
the actual surface itself. It's a type of
procedural mesh that gets generated for the water,
including the river and everything else. I'm going to try
to show you this. You can see the blue mesh
here is the WaterMeshActor. It automatically identifies
where the rivers run and the lakes are. And it wraps everything
together so it becomes one large, unified mesh. This is why it's
completely seamless. The blends are done
on a material level. This water mesh
actor is very interesting because, for example,
it does LODing. It simplifies itself,
as you can see happening over here already. And that's another
thing we're going to talk about when we
talk about performance. But that is the
WaterMeshActor. Now, the WaterMeshActor
is basically just existing. There isn't a great
deal you can do with it. But one thing we're going
to talk about in a second is far water, which is the one
feature you could probably do want to-- Over here,
you have far distance, and maybe the
LOD settings as well. That's essentially what you
want to look into over here. But again,
returning to that in a second. Now beyond that,
it's doing something else, right? The WaterMeshActor
isn't just one giant mesh. It's actually divided
into water bodies. And again,
the mesh itself has LODs. It's simplifying
itself at distance. It's very similar to what
a landscape does as well. Now, the water bodies-- we can display these with
a command called r.Water_WaterMesh.ShowTileBounds. And we're going say 1. And so what we
have over here is this. Let me switch back to Lit mode. So it divides it into cells to
help control the water body. So again,
on a daily usage case, this is not going to impact you. But this is what it's
doing behind the scenes, just to highlight how it works. On top of that,
there is the visible surface itself, the material. Now,
the material is based on two things. It's based on an
actual material, so an editor material as
made over here in the editor. We can see this in
the plugin of Water-- so in Water content,
which is what came with the Water plugin. And in order to see this,
by the way, you need to have enabled Show
Engine Content and Show Plugin Content. And in here,
we can see the default materials. And we can see Water Surface. And here,
we have a Water_Material. This is the default
water material. So it's the regular material
where a lot of the work was done with expressions by
the artist in a regular material. So a lot of what it's
doing-- the waves, river flow maps, beach foam,
fluid simulation, masking-- all of that
was done over here. It's divided in these
different functions. So you can edit it. And that's exactly what
I've done for my real sea. But you can edit it,
modify it as you see fit. For example, this is
fluid simulation and so on. You don't have to touch this. Again,
you can just use ready-made material and go from there. But underneath that is
something else underneath. Underneath that is
custom HLSL. Shader language have
written a new shading model called SingleLayerWater. And that's what is providing
a lot of the additional-- well, the shading,
essentially, obviously. But it is going to make it
look much more like water. Setting the shading
model to SingleLayerWater gives you, for example,
this block over here with some additional settings who,
again, control how it responds to light. The other very
interesting thing to note here is that the water
material is going to be opaque or masked. Now,
it's masked because then it allows you to cut a hole into that. And again, this is a topic we're
going to touch on in a second. But it would normally be opaque. And yet-- and I think this
is really interesting from a technical point of view-- and yet it looks translucent. So this is essentially
fake translucent. It's not actually translucent. Water material is rendering
as an opaque surface. What it does is it
renders in another pass. And as it renders
in another pass, it has essentially
already rendered to surface underneath the ocean. It already has that
information available. And it can use that
information to blend together with the opaque
surface of the ocean to make it look as
if it's transparent. That's what we're seeing
happening over here. That gives several really
important advantages. For example, it makes it
easier and more powerful to get better shading going. Because it's not a
translucent material. It's regular opaque material. It prevents sorting
issues between waves, which you might have
gotten if it is translucent. And for performance,
it also renders a lot faster. That is controlled, by the way,
by ColorScaleBehindWater is controlling how
much of what's behind the surface
is rendering true. We'll talk about that when
we talk about caustics. And then finally,
the last part of how this works is the waves themselves. Now, the waves are
based on Gerstner waves. So in shader language,
we've set up a function that handles the
generation of the Gerstner waves. And a Gerstner wave,
by the way, is a relatively straightforward
way of calculating realistic waves. It's a wave generation model. So we have that in Shader
language behind the scenes. And then the material is tapping
into that through this ComputeGerstnerWaves thing. If you look into that function--
because this is actually making the 3D waves-- if you look into that function,
it's primarily this one
over here where it's retrieving some of the
functionality that's been-- some of the waves have been
calculated through that shader in the background. And that is essentially it. So again,
we've made sure as much of it is exposed, and controllable,
and tweakable as possible, just like with everything
we do in the engine. So let's move on to looking at a
few more advanced cases here. The first thing we're
going to take a look at is far water,
so the distant ocean. And then we'll move
to making things float. Before we do so,
here is the actual level. So this is what
I've been building over the last few months. That is a beautiful
lighthouse here. We've got a sea. And we've got waves in here. And there's a
lot of stuff in here that's a lot more than I
can cover in this video. So there's going to be some
followup content, for example, on our livestream that's
going to dive further into it. But one of the things
I wanted to do here is make a stormy ocean with
more foam, and more structure, and complexity to it. And again, going further
on the point of, how much does the system allow you
to extend it and modify it? Well, quite a lot. And that was a
challenge I took up here. So here's my whole scene. I have a house on
the dunes over there. That's the cable
running to the lighthouse. There's a little boat over there,
et cetera. We've got a lake over here as well,
kind of a strange lake. It's got a river flowing over. And the river branches
in two different arms here. There's another arm over there. And then it flows
out into the ocean. So this is the scene
I'm going to use for the remainder of this talk. But let's start
with the far ocean. So the far ocean means
that by default, a water mesh would end over here. You can see a cut over there. And that is where the water
mesh would normally end. That is going to be too close,
typically. You're going to want to see
an infinite ocean surrounding the environment. So this thing over here is a
simplified lower-poly mesh that also gets
automatically generated. It's called the FarMesh. That is set in the
WaterMeshActor in the section FarDistance,
where the only thing you have
to do is specify the material and specify how far it extends. You can see if I remove
this and replaced with zero, this is what it would be by default.
And that's it. The material-- this is my
own version of the material. But by default,
the material is already made. So you would simply have to
go to the Water plugin content folder, where you would
see FarMesh over here. And that's the one you fill in. And that's it. Next up is buoyancy. Buoyancy can be done
in a few different ways. The most advanced
and powerful way-- but also the one that's
most work-in-progress-- so this is very much so
the first iteration of that-- is using a buoyancy component. So by default as well,
in the Water plugin content folder, there is a BuoyancyExample. It's a Blueprint. But in that Blueprint--
and this is that Blueprint in the world-- there is a component
called Buoyancy that allows you to make
things float in the water. So this ball,
when I go over to Simulate here, it will fall into the waves. It's going to float, and it's
going to follow the waves just like that. The only thing you do is
you add the component to it. And you're done. It's floating. This means it has physics. It has collisions. It has the whole thing. So presumably,
if you were to have a game where you
can push this ball, you would be able to push it. It's going to flow
over the waves. In fact, I can probably do like this,
just drag it out-- although that's a
little bit aggressive. But in any case,
it's going to skip over the waves until eventually,
it has too much strength. It's going to sink. And then it's going to
probably float back up. But I might have pushed
it outside of bounds. So it's fully physics-driven. That being said, this component
doesn't have any settings yet. It's not going to work under
every circumstance yet. It's a work in progress. But that will be the
most powerful way. Now, you don't always
want to do it that way, though. Oh, and by the way-- also really cool
about this one-- if you were to add this buoyancy
component and this mesh in a river,
it's going to understand the velocity of the river
and the flow of the river. So it's actually going
to be dragged along by the strength of the
river and brought forward to wherever the river ends. So it actually
supports that too. But if you just want to
have a visual way of making things float,
there's a few different ways you can go forward. For example,
we've got this thing over here, which is always
very difficult to select. So it's going to
take some effort. But once I succeed in selecting
this thing-- there we are-- this has been done
entirely through the material. So the really cool thing here
is that any material can sample the surface of the water. And therefore,
the material knows where the water is at
that given point in the world and can offset
itself based on that. We look in the
material of this mesh, and we're going to see this. We're going to see
world position offset is set to Material
Function Follow Waves. Now, this is not a standard one. I built this one. So you're not going to
have access to this yourself. But actually, if you look inside,
it's very, very simple. Because this is what it does. And this is optional. So ignore that. The only thing it
really does is this. It takes the standard function
called ComputeGerstnerWaves, the same one used
in the water surface itself, in the ocean material. It gets water time,
and it needs a position. Normally,
the position would be world location. And if you were to input
that in a material, it's going to deform
entirely based on the waves. So you could make
a piece of cloth, for example,
that's going to match the shape of the waves that way. But we are using Actor
Position as position over here. This then outputs World
Position Offset-- so WPO. And that would go into
World Position Offset there. And that's all you have to do
to make the mesh understand where the waves are. Obviously, this is not
going to respect a collision. So it's purely a visual effect. You might need to change
the bounds as well on the mesh. But that's it. Now you can go even
further with that, which is the next really cool part. And you could say,
well, what if you were to do this on a particle,
right? Here we are, let's go over there. And let's enable that. So, how to activate-- I'm going to enable that. And what will
happen now is that it's generating some particles
that are also following the waves. In fact,
they do some more advanced behavior. They actually go faster
when they're riding a wave. And they slow down when
they're in the valley of a wave. They also rotate further. And the really
interesting thing is they understand
where the ground is. They will beach themselves
on the ground like that one just did over there. And when the next wave comes by,
it will be picked up again
and pushed a little bit further. So now it's cubes that can beach
themselves, follow the waves and beach themselves
on the beach. If you take a very quick
look at how this was done, it's using, very much so,
the same functionality. So here's the Niagara particle. It's a very simple particle
except for this custom module. And in this custom module,
this is what it does. Now, it's quite a lot. A lot of it is pretty simple. It's just modifying
rotations and movements. What is particular
here is this thing there. This allows you,
just like in the material, to sample the
surface of a water body or the water mesh and body,
technically. And it allows you to
sample the height, depth, and other things. And then based
on that information, we're making the
particles do different things. So again, everything is
supporting everything else. Everything is tied together,
as is always the case with everything
we try to do and work on in the engine. Lastly, we'd like to talk about
making holes in the surface. So we're also supporting
that in case you want to make, for example,
a building that's built in the water and then allows you to go,
essentially, under the surface. We have a thing called a
Water Body Exclusion Volume. So it's a volume that you place. And we'll place it over here. There we are. And where you place that volume,
you can remove the
post processing and remove water as a behavior at that location. Now,
it's not going to remove the mesh. The mesh is going to depend
on it being a mass material and moving a mask map. There we are. Now,
there's a lot of stuff in here. But I'm looking
specifically for Hole. So I've got a
parameter called Hole. I'm going to enable that. We moved it out of the way. Enable that. You get a hole right there. And there is no
post processing here either. You can go entirely
under the surface. The water has been removed. The way this was done-- and I'm going to show
you the basic material here to make it easy. Here's a very
basic water material. This is an example. It was by using this over there. So world position-- this
is how it's offsetting it, enabled or not. And it's essentially
using this texture, which is the main thing. It's using that square. And it's moving that square
around on the material. And this would
then go to masked, which is clearly disabled. But that's it. That's how you would
make a hole in the surface. A few more things
there to wrap up-- you can make a very large wave. And a simple wave-- I'm going to simulate a game. I have a small
Blueprint set up that's going to trigger the wave. And again, it looks very simple. It's just a proof of concept. It needs further attention. But it shows again that
it's possible to do this. So it creates a
large tsunami wave that is now going to
travel towards the beach. And then it's going to be very
anticlimactic because it's just going to fade out
once it gets here. But the way it works here is
that we're moving the water surface with a mask
map as well-- so very similar to the
hole in the surface. We've got a mask map,
which is, in fact, the same one. You can see the wave
one is the white shape. That's going to blend
over the surface. And we're going to offset. We'll use that to offset the WPO,
so the World Position Offset. We've bumped that up. So we give it an offset
Z based on where that wave is located. So you can easily
modify the world position offset to create different
kind of waves and experiment as you see fit. The only thing to note here is
that since the water has tiles, each tile has a bounce. And it might occlude. So there's actually a property
in here somewhere that allows you to set the
max wave height offset in order to basically offset
those bounds to prevent any occlusion popping. So you'd want to clean it up. Caustics will be the next point. I've made my own
custom caustic setup. It's somewhat difficult to show
over here with the rough waves. We can see we have
basic caustics over there. There is a built-in,
work-in-progress caustic system. In Water Content,
in Blueprint, you're going to find Caustic in here. You're going to find some-- actually, just if you look
for Caustic here in general, you'll find things
related to caustics. And you have to set it up. You're welcome to
experiment with that. I made my own basic version,
again, to show that that can
be done and that it might be easier to experiment
with these things than you might imagine. So you again look in the basic
material here, as an example. I made a function
called Water Caustics. And this would have been input
into ColorScaleBehindWater, which is a scene rendered
as behind the surface of the water. So if you modify that,
you can make caustics appear on the
ground underneath the surface. And in there,
that's a little bit larger. But what it essentially
comes down to is taking this texture
with caustics in there, multiplying,
panning it a little bit, and blending that with
the existing underground. Similarly,
there is a way of creating ripples and other kinds of impacts. So I'll switch over to this
different scene over here that we have prepared. There's two actors there. In the Water Plugin folder,
you have a FluidSimulation folder where you have two Blueprints. There is a Blueprint FluidSim
that needs to be placed. And you have some additional
Blueprints that you can use. For example, in Examples,
you've got a couple of these. You can-- again,
is this a work in progress. It's an experimental feature. Experiment with it
and see what it does. I put it on this sphere. If you simulate now,
this is making ripples. I can drag it. Everything moves. So you can attach this,
for example, to a boat, or the player,
or something that's moving on the surface. This is definitely an area we're
going to continue to work on. But this is what's
implemented right now. Now, to start wrapping up,
in terms of performance, this has been used
already by Fortnite and across all the different
devices that Fortnite runs on. So it scales on all of
these different devices, including on mobile. It's proven to run
well performance-wise. It's proven in production. It scales across
these different devices by doing two things primarily. On the material level,
it's going to be down to the artist making the water
material to build in feature-level complexity
switches or water material quality switches,
and to essentially manually disable certain arms of the
functionality where necessary. And you can adjust the density
of the generated water mesh actor. So that means that
this mesh over here, if you look in the
Wireframe mode, you can see it's quite dense. This is scalable with the CVar. So you can change the
complexity of the mesh at runtime at any one point. You can change the
LODing of it and so on so it becomes simpler. In fact, these are some of
the CVars we use for usability. You can experiment with
these and see what they do. For performance scalars,
it's this bottom two that are primarily affecting the
complexity of the water mesh. You also have Stat
Water and Stat Watermesh. For example, if I take the Stat
Water Mesh here and try it over here in this project,
we can see how many vertices and how many
tiles we're drawing, and how many [INAUDIBLE]. So we get some
information on that. And lastly,
just to really point out again, experimental feature-- so there are limits that it does
require a landscape to work. Technically, you can get it
to work without a landscape. But it is definitely made
right now to use a landscape. It's going to expect
that landscape to be relatively small in size. So it's going to
be-- a 4K resolution landscape would be doable. If it's 8K or larger,
you're probably going to hit an
issue at the moment. And it does expect that the
world exists at world center or close to world center. OK. So there are some limitations. And we're definitely going
to continue to working on that. In fact,
in terms of future plans, here's what we're looking at. We've already wrapped up
work on a Wave Asset Editor. So that's that wave
asset as discussed in the beginning of this video. But not only will it
have a preview window that actually shows you
the settings on the 3D water preview, essentially-- we want to look into decoupling
water from landscapes so it becomes more universally
applicable to any kind of setup and any kind of
environment you might have. We are aware we need
to go further in terms of supporting larger worlds. And there's a number of
additional work-in-progress features we'd
like to continue on as well-- so caustics,
the whole system around forces, and impacts,
and hitting the water, and creating ripples,
all of that. We're going to continue on that. By extension, anything related
to the player or other forms of interactions of physics. That includes, also,
swimming for the player and anything in that direction. That's an area we
have to expand on. And we're working on
improved physical-based waves. So we're looking at
using real-life data from actual ocean studies
and making it more wind-driven. So that's coming in the future. To wrap this up,
as it is right now, you can already create
beautiful environments with the new Water as a Feature
system in a matter of minutes. And that wraps up my talk. Thank you.
Great intro to the new water systems in UE 4.26 by Sjoerd de Jong.
For those wondering, the plugin is still experimental, but it's already looking pretty robust :)