The Subobject Seleciton rollup contains all the selection related tasks. All of them are UV SHELL BASED, which means that the system handles a UV SHELL as an INDIVIDUAL OBJECT.

For example if you perform a Loop or Ring selection, the loop won’t go through the seam.

To perform a certain selection on an object, you have to select at least one edge on a shell to count it into the modification of the selection.

Loop and Ring

Select By Smoothing Groups

Select By Material IDs

Select By Seams

Select Edges By Angle

Texel Density is a very important thing, especially in game development. This is the value that tells us the relation between the UV, the 3D Mesh and the Texture size. The unit of measure can be px/mm, px/cs or px/m etc… In our case it’s px/cm. (which might change is the future and possibly it will be attached to the System Unit)

Usually in game development, commonly used values are 5 px/cm, which means a 1024×1024 pixels texture will cover a 200x200cm area. This gives us an approximate 5.12 px/cm texel density, which is 0.512 px/mm or 512px/m. (in other a single pixel will be 2 mm)

The texture density is calculated using the following equation:

TD = √uvArea / √geoArea * tRes

Which is in short the square root of the uvArea divided by the square root of the geometry surface area, multiplied by the texture resolution.

You can get the actual texel density from a selection, which is always extended to an entire UV Shell, even if you have only a single face selected. The set also scales the entire UV shell even if only a single face/edge/vert has been selected.

Ths Display Rollup contains two things only, but they are pretty important.

1. The Seams Display Toggle
2. The Mapping Channel

Display Seams

Mapping Channel

UV Packing in UVReactor is polycount independent, which means it will barely affects the speed of the packing. In other words the system doesn’t really take care of how many polygons you want to pack, it will not affect the performance. This is due to a technology that uses a model that can represent each UV shell in an abstract way.

The packing algorithm consists of 4 properties.

1. Packer Resolution (this is not the resolution of the texture map, but the packing resolution) The higher the number leads the more precise the packing.
2. Num Threads defines the number of threads for Multi-Threading. This value is the number of cores you want to use, minus 2. So on an 8 threads machine, it’s 6.
3. The padding relates to the Packer resolution. In this case it will be 1 pixel for a 512 resolution. If you are using 1024 as the Packer Resolution, then it must be modified to 2, to get similar results.
4. If the “Pack Selected” checkbox is checked it will pack only the selected UV shells, when you are working with a single object. In case of multiple objects the algorithm will pack everything.

Currently the packer doesn’t use any kind of heurestic, which means you have to find the ideal Texel Density for UV Shells. The packing is vert fast despite of that. The heurestics will be added later to the system and in that case the UVReactor will find the appropriate texel density for you, to get the best result.

Also the packing only supports the 0..1 space right now.

Note: If you have unselected shells in a UV Space, then the algorithm will keep them in their location and it will pack the rest of the UV Shells around them.

This contains two simple algorithms that you can use to organize UV shells in a single row, by their area or by their fill size value.

The fill size value sorts all uv shells is a songle row or column by their boundary size and (uv area / boundary area) ratio. This way you can get an idea how the UV packer sorts the uv shells and in what order it place the uv shells into the uv space.

Currently the simple area based sorting is missing from the BETA build yet, but will be the part of UVReactor later.

The scale rollout contains all the discrete scaling options. With this panel you can scale each individual UV Shells around their center point. You can use negative values as well and it’s also possible to scale only on the horizontal or vertical axis.

Rotate is similar to the Scale Rollup. It performs a discreet rotation on all the selected UV shells about their center points. This field can also handle negative values if necessary.

Grouping currently is placeholder and it’s only suitable to store Selection Sets. If you are using UVReactor (means that UV Reactor is open, it updates the underlying data structure after each modification, so all of the faces inside a UV Shell will use the same ID, even if you are modifying the toplogy of the geometry or the UV.

Note: the update choses the most frequent ID in a UV Shell and it will change all the rest of the IDs to that one.

Edge Align is a simple tool to rotate your UV shells horizontally or vertically based on an edge selection. It is especially useful, when you want to align UV shells to the horizontal or vertical axis of the UV space.

The selection can be average in the same shell and it can be used on multiple UV shells as well.

The backdrop image rollup is a simple solution to load in any kind of texture into the background, so if you have tiled textures, you can properly align the uv shells. You can also modify the opacity of the backdrop image if necessary.

Later I’ll update this functionality, like using the image from the actually used textures from your scene or with UDIM support or even with automatic Material ID assignment.

Note: the loader uses the build-in max image library so it can hangle the same image formats as 3dsmax.

This one is a bit odd-one-out, because it’s not necessarily UV editing, but using UV data to do certain tasks.

The Smooth By UV Shells makes it possible to turn smooth edges to hard edges or hard edges to smooth edges based on the angle along the UV seam. This was a request.

In the future, I’ll extend this panel with other functionalities.

The flattening rollup is one of the most important part of UVReactor. Here is the place where you can relax your UVs into a non-distorted UV shell. The algorithm is very fast and prevents triangle flips in most cases. (currently overlaps can still occur)

Flattening with UV Reactor

The flattening needs an initialization, which you can do with the Init Circle Button and then clicking on the Flatten button will relax it into a non-distorted state. The Initial state can also use a square boundary.

UV Reactor Planar

The planar mapping in this case differs from the one you can find in the Unwrap UVW modifier. This planar mapping always uses a plane perpendicular to the average normal of the geometry faces that constructs a UV shell.

Straighten

The straighten algorithm in UVReactor easily outperforms the one that can be found in the native UnwrapUVW modifier. This algorithm averages the loops to get create a flattened UV shell.

There are still distortions if the rope have different diameters, but this will be fixed in the future.

UV Topology is the other crucial part of the system. It consists of two functions.

1. Stitch
2. Break

Stitching Seams

Stitching can use Snap To Selection which is turned on by default. This feature also resizes the UV shells to match the size of the target. (it caluclates the scale using only the edge selection and not from the texel density)

Breaking Seams

Note that breaking seams can be done using EDGE and FACE selection as well.