Still alive.

It's been a while and I've got 3 more examples about mapping a texture to world coordinates almost ready, but these days I'm very busy with some other project of mine.

I also draw (on paper, yes, Sir) and I'm preparing my first exhibition.

Happy scientific accident.

I was in photoshop and intending to use the gradient map. (Image > Adjustment > Gradient Map)

I accidentally clicked an existing saved gradient and realized I had made sort of a scientific texture.

You know, like that sort of stuff:

 Here's my photoshop gradient:

And that's the result on my texture:

The real question is: what on earth did I create such a gradient for in the first place??

Mapping a texture to world coordinates. Part 2.

Example 1: blinking mask

Back on Enslaved, the environment artists used this method to map a gradient that would reveal some floor lights along a corridor so they would appear to blink sequentially.

This setup is very simple. This is the texture I'm using:

(It's actually vertical but I rotated it for the sake of this post's layout.)

Since there's a lot of black it will repeat less often.

And this is what the unreal material looks like. As you can see, it's nothing different from what I described in the previous post.

Now in the map, I've just put down a few small cubes with that material on and there I have my blinking lights (sort of).

and here's what the map looks like with the material on the ground plane.

It actually took me longer trying to optimize those gifs than it took to make the whole thing in unreal.

This is not the most exciting of all examples but more will come. Stay tuned.

Map a texture to world coordinates. Part 1.

Today we'll start looking at mapping a texture UVs to the world coordinates.
It's taking quite long to write the whole thing up so I'll keep the examples for later posts.

Mapping to world.

We've looked before at remapping a texture with another texture. The coordinates of a texture have vertical and horizontal data, which you can remap to whatever you want.
‘Whatever you want’ can be the world coordinates.
We're going to use the world position, but we need to divide it to start with. The values not quite usable as they are. The more you divide the world position, the larger the texture will be. It's sort of like zooming in your world: the texture appears larger.

The result is just like setting your texture tiling in a texture coordinates node.

Dividing the world by 500:

 

Dividing the world by 100:

Unlike your world, a texture has no depth, it only has two axis.
Next thing we need to know is the way your material will be oriented in the world so as to map the texture to the correct two axis. Imagine that you're facing a plane with your material on it. Which axis do you see pointing away ?
 
In our example we want to map it to the ground. If we look down from above, we see the R and G arrows pointing away. The z channel will not be visible.

 
So we use a component mask to keep only the R and G channel (x and y).


 Bear in mind that the texture will stretch along the third axis, the z axis in our case.

<teaser>
Would we be to use lerps and map the texture several times along different axis we could start to get a 3D feel. (at a cost obviously)
</teaser>

That's it for today, several examples will come soon.

Keep it local.

I'm preparing a future post which is growing by the minute. I'll probably have to break it down a bit to keep it clear. Here's a bit I'll refer to in the (near) future.

I mentioned the World Position minus Object World position to make things local before, but I didn't explain it properly. 

 The WorldPosition gives you the world position value per pixel, whereas the ObjectWorldPosition gives you the world position of your object, just the value at which its center is.

When you subtract the ObjectWorldPosition to the WorldPosition it means that every pixel will have a fixed value wherever you place it in the map. The value becomes relative to the center.

 

Imagine that this quad is in the world. We check the value of the same pixel at different arbitrary locations. WorldPosition - ObjectWorldPosition always returns the same value.

(Remember, if you're thinking of a formula don't just keep it abstract. Give it some numbers to verify that the result makes sense.)

This set up is useful if you want to be able to move your object around and you want the material to stick to it, it is also good for you to ‘tame’ your value.

Sometimes you can be testing a feature in your test map, but as you implement it in the game, some things will go crazy. Depending on where you are in a map, the output of the WorldPosition could range from 1 to tens of thousands. Would you be to use the WorldPosition as, say a multiplier, you can see where the troubles start.

We had that in DmC 5 with the summoner. She's a flying enemy so the character team put some vertex offset in her hair to give it a floating motion. To do so they used the world position to drive some sine waves. The first tests were looking good in the test map but her hair first went all over the place in gameplay. The fix was just a matter of subtracting the ObjectWorldPosition to the WorldPosition.

Stretched Mask.

When you pan a warped texture, it can be annoying to see the patterns repeated too often.

If you're going to pan it only or mostly in one axis, what you can do is create a long rectangular texture and use a small tiling value on the long axis in your material (0.1 in the example below). As you create the texture, you need to keep in mind the ratio it will be used at.

The top texture is the original with unmodified UVs.

 

You could for instance use this method to create a wobbly mask that will bring an illusion of flowing liquid.

Masking a volume.

Today we'll look at defining a 3d mask.

I originally made this set up for a quick and dirty rain test. The rain was one big gpu particles emitter, no collisions, no nothing, so it was raining indoors.
The dirty approach to solve this issue was to make the rain transparent in the indoors volume.

The idea is to define the range which will remain white in each of the x, y and z axis and then multiply everything together to define the volume.

Defining the range per axis.

We're using a set up I've already described so I'll be quick there. (Told you I liked to use it all over the place.)

 

 For each axis, we're remapping a range of values to a gradient from 0 to 1, then we will also ceil it and clamp the result.


We do it for the min, and we end up with 0 below the minimum and 1 until the infinite.
We do the same thing again but we invert the values (min becomes max and vice versa) so we end up with 0 above the max and an infinite 1 in the negative direction.
Finally, we multiply the min and the max.

Now our range is 1 and any value above or below is 0.

Doing it the proper way.

That was the simple way of explaining it and the way I actually created the original material, but while I recreated it for this post I realised the set up could be simplified a lot with a decent saving on instructions count (34 instead of 43). The idea is the same but we're dealing with all 3 channels at the same time for the mins on the one hand and on the other hand for the maxs. After we've been through the value (world position in this case) minus min / divided by max minus min / ceil / constant clamp, we separate the 3 channels (with a component mask) and multiply them by one another.

We end up for the mins with 0 below the min and an infinite 1 along the positive of each axis, and for the maxs with 0 above the max and an infinite 1 along the negative of each axis. 

Multiply mins and maxs together and you've got your volume.

In the following video, I'm moving the emitter around so you can see that the coordinates are in world space. (I applied that material to a bunch of simple sprites.)




We could also make them local space if we'd fancy that, by simply subtracting the object position to the world position.