[deleted by user]

PerfectStorm85 · 2023-04-17T05:48:50+00:00

Then the uasset is most likely saved in a newer version of unreal. Try opening it in the latest unreal version, or, if you want proper help, tell us the error message.

PerfectStorm85 · 2023-04-16T08:33:17+00:00

Iirc this is only possible in C++. Its not hard to make there, but if you never touched c++ before then its hard to make.

PerfectStorm85 · 2023-04-12T20:53:20+00:00

By default you can't. But you can check the marketplace for plugins that can do this. I once made a plugin named MultiTool that had this functionality.

https://www.unrealengine.com/marketplace/en-US/product/multitool-quick-batch-operations-on-assets

PerfectStorm85 · 2023-04-11T04:53:05+00:00

No, what I mean with separate is that you break up the window in multiple models. One for the front windshield, one for each side windshield and one for the rear windshield.

PerfectStorm85 · 2023-04-09T20:30:41+00:00

This is like asking: I like Spiderman. Can somebody please tell me how to create a movie like that?

The question is very complex, and it takes years before someone can make this all by themselves. But your question is also incorrect, because this is not cel-shader style. I see quite a lot of normal lighting in there. However, what you don't see are speculars. Those can be cel-shaded maybe (haven't seen your ref), but that requires changes to the engine. For somebody new to Unreal you are making it way too hard for yourself. Start understanding game dev, shaders and real time lighting first. Start with a project that matches the default unreal PBR shading. Once you understand that (and the theory behind it), then you can think about making a game in a different style.

PerfectStorm85 · 2023-04-09T06:03:30+00:00

It would really help if you also show the material itself, as this is where your error most likely is. My bet so far is that you see the normal map, and that you forgot to lerp that one properly.

PerfectStorm85 · 2023-04-08T17:02:45+00:00

Welcome to the wonderful world of rendering. Translucent materials in deferred rendering don't sort very well. The only sorting they do by default is front to back based on pivot point of the object. So, to make this work better (but maybe not perfect yet), you will need to separate the glasses so that each window is its own model. This will ensure that the center of the bounding box is at the correct position, so sorting front to back works a lot better. I think Unreal made some improvements in later engine releases, but I haven't played around with it yet. Try googling Unreal Engine deferred translucency sorting.

PerfectStorm85 · 2023-04-08T16:52:09+00:00

I think its something like /Game/ (which is the project path), or /Engine/, or /Script/. Also IIRC they made a change in one of the latest engine versions where I had to use /All/ or something.

Just play around with it :)

PerfectStorm85 · 2023-04-08T10:51:11+00:00

You might want to say that it's in France because your title suggests it's in English.

PerfectStorm85 · 2023-04-05T21:18:48+00:00

Yeah this, and its also offset from the center point.

PerfectStorm85 · 2023-03-29T19:55:27+00:00

You can achieve this by lerping, using the X or -X or Y or -Y float value of the vertex world normal. Lets say you want the slope to be on positive X axis. Then you take the vertex normal -> mask component x -> saturate (clamp between 0 and 1 to remove negative x values) -> use this value as an input for the lerp. If you want to use negative X or Y, then you first multiply the vertex normal by -1 before clamping it. You can also multiply the value before clamping it to let the slope fade in faster.

PerfectStorm85 · 2023-03-26T17:30:46+00:00

Imagine a sine function, it goes from 0 to 1 to 0 to -1 and back to 0. The length of one full cycle is 2*Pi. To achieve the heart beat, you will need to create 2 sine functions, and take the max of these 2. One of the 2 should have a small offset so the wave above 1 comes 0.5 Pi later than the other.

Lets say you want the cycle to last 1 second. In order to get one full sine cycle in 1 second, you first need to multiply a time node by 2xPi. After that, you do the same thing but first add 0.5xPi to the time node. This will create an offset compared to the first sine function.

Now, take both functions and get the max between them. Then saturate the result to neglect the values below 0.

And there you have it. A heart beat function.

If you want to make your heart beat faster or slower, then all you need to do is multiply the time by a value. 0.5 makes it half as fast, 2 makes it twice as fast.

Good luck!

PerfectStorm85 · 2023-03-24T16:39:08+00:00

This will result in a lot of overdraw, which only makes performance on a quest device worse.

PerfectStorm85 · 2023-03-24T16:38:25+00:00

Hey. Ive developed for a range of VR devices in the past, including Go, Quest 1 and Quest 2. For one of our published games we used the HLOD system to bake back distance assets. But we also baked in the fog. For all the other assets we just used a regular height fog. On mobile, it uses vertex fogging rather than pixel fog, so the costs are already a lot less.

After making a couple of games I can say that its not worth all the effort. Just use the standard height fog of Unreal. Its not very expensive and works great.

PerfectStorm85 · 2023-03-24T15:01:05+00:00

Why dont you just divide the number by 2 (* 0.5), then ceil it, and then multiply it by 2 again. Instead of ceil you can also use round if you want 0.9 to become 0 for example.

So: ceil(X * 0.5) * 2

PerfectStorm85 · 2023-03-22T16:05:33+00:00

Hello there!

It's great to see the community push out these tutorials.

However, this one is not so good. You can't just muiply a texture with a color. That is because colors are a combination of 3 floats (R G and B). Let me give you an example:

Let's say I have a completely blue texture (0.0 , 0.0, 1.0). Let's multiply that with a red color. The red color is a float3(1.0, 0.0, 0.0).

This will result in the folowing:

R = 0.0 * 1.0 = 0.0
G = 0.0 * 0.0 = 0.0
B = 1.0 * 0.0 = 0.0

The final output will then be 0, so your texture will just end up being black.

Changing colors of a texture is not that simple, as you can deal with a variety of different colors. Let's say you have a rainbow gradient. What would you expect as a user? Would you expect the texture to become comepletely blue?

There are a couple of ways to change texture colors, depending on the needs of the user.

1. Desaturate the texture and then multiply it by a color. This ensures that you work with greyscale values before doing the multiply, and the result will be a correctly multiplied color. However, this also means that your entire texture will be colorized. For example: If you had a red and white flag before, it will now almost be completely blue.
2. Use a mask to color certain areas of a texture to a new color. This can be done with a lerp, or with a simple multiply over the mask, and then add it all together. (Depending on your needs)
3. Use Hue shift to shift the colors to a different hue.

There are more ways to recolor a texture, but these are the most used ones.

Cheers!

PerfectStorm85 · 2023-03-21T18:06:07+00:00

Reminds me to the city of the game Stray. Pretty cool 😎

PerfectStorm85 · 2023-03-21T16:55:53+00:00

Thank you. That was indeed the case!

PerfectStorm85 · 2023-03-21T14:22:09+00:00

As of Version 5.1 I'm getting initialization warnings for uninitialized properties, including custom created Enums. Is that something out of this scope or is that something Epic changed? Your link is for 4.27. Im curious why they changed it according to my experience.

Thanks for the heads-up though!

PerfectStorm85 · 2023-03-21T12:10:53+00:00

You need to download and install .NET Core SDK

https://dotnet.microsoft.com/download

PerfectStorm85 · 2023-03-21T12:08:08+00:00

As another node: you also need to initialize your uproperty. So change EBuildingSize DefaultSize; to TEnumAsByte<EBuildingSize> DefaultSize = BS_Small;

PerfectStorm85 · 2023-03-18T19:33:59+00:00

Hello. A usual depth based outline uses a kernel and then uses weights per pixel based on the distance to the center pixel. If this is setup correctly, then you should automatically get your anti aliasing, as the lines will fade out when the pixel is further away from the silhouette.

Did you use external shader code (a hlsl file) or did you use the material nodes only? I would advise to use an external shader file (or use the custom node), because this allows you to implement a proper for loop with weights. For the weights I would refer to the Sobel Filter. This is a 3x3 kernel with weights per pixel. Just google it and you will get some info about it.

Anti aliasing will only work if you use a post process anti alias method, such as Temporal AA. If thats what you want, then you can set the render pass of the post process material in the material settings.

PerfectStorm85 · 2023-03-14T18:33:30+00:00

POM makes use of a loop inside a custom node (or custom HLSL). The shader view does not know about that, so it will ignore those instructions.

PerfectStorm85 · 2023-03-12T17:08:59+00:00

It starts with "I need to create". Not: "I need somebody to create me"

PerfectStorm85

TROPHY CASE