Diving Into the Depths of Water as a Feature in Unreal Engine 4.26

Video Statistics and Information

Video
Captions Word Cloud
Reddit Comments

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 :)

👍︎︎ 3 👤︎︎ u/SirIndianCurry 📅︎︎ Dec 04 2020 🗫︎ replies
Captions
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.
Info
Channel: Unreal Engine
Views: 185,866
Rating: undefined out of 5
Keywords: Unreal Engine, Epic Games, UE4, Unreal, Game Engine, Game Dev, Game Development
Id: d5Ft7UaYayM
Channel Id: undefined
Length: 35min 12sec (2112 seconds)
Published: Fri Dec 04 2020
Related Videos
Note
Please note that this website is currently a work in progress! Lots of interesting data and statistics to come.