Our main content creation software is 3ds Max, so we created a Macro Script (in MAXScript) for this problem.

Recursive or iterative approach

There are basically two possible approaches to handle this problem. The iterative first oneone iterates through all faces for setting a random material ID while the recursive one version divides the big vast amount of faces into smaller parts groups(groups?) and then assigns a material ID to all the elements contained in this group. ?.connected to the face selection.

At first we implemented the iterative approach to take a look at its possibilities and restrictions. After that we thought about possible optimizations and other ideas how to solve this problem more efficiently with an optimum balance of between speed and a visual qualitygood result. That’s why we created further looked into the a recursive version to solve the problem from another perspective point of view.

Algorithms

Iterative version

function changeIDsIterative obj minID maxID stepSize =
(
	getElement = polyop.getElementsUsingFace
	setFaceID = polyop.setFaceMatID
			
	range = 1
			
	for i = 1 to obj.numfaces by stepSize do (
				
		randomID = random minID maxID
				
		range = i + stepSize
				
		if(range > obj.numfaces) do (
			range = obj.numfaces
		)
		
		element = getElement obj #{i..range}
		setFaceID obj element randomID
	)
)

Basically this script iterates through all faces with a given step. There it takes the takes the elements which are connected with the faces within the step range and gives this selection of faces a random material ID in the range of the minimal ID and the maximal ID (minID <= ID <= maxID).

Larger values of stepsizestep size would give result in more speed by skipping a lot of faces but would result in a visible repetition of the same used material ID.

So the number of function calls when to setting a random material ID depends on the step size s:

You may have noticed that in the first two lines two function calls are assigned to variables.

getElement = polyop.getElementsUsingFace
setFaceID = polyop.setFaceMatID

That’s because ofThis is done for performance reasons. By Iinitializing the function call as a variable these many function callswill allow it to run are slightly faster.

Recursive version

function changeIDs depth obj minFace maxFace minID maxID =
(
	if(depth > 0) then ( --Clustering, if depth != 0
		partSize = ((maxFace - minFace) / 2 + 1) as Integer --calculate the clustersize
		
		changeIDs (depth-1) obj minFace (partSize + minFace) minID maxID -- first part
		changeIDs (depth-1) obj (partSize + minFace + 1) maxFace minID maxID -- second part 
		
	) else ( --set material IDs
		getElement = polyop.getElementsUsingFace
		setFaceID = polyop.setFaceMatID
		
		randomID = random minID maxID 
                --get a random ID between the given values
		element = getElement obj #{minFace..maxFace} 
                --select all elements with faces in the given cluster of faces
		setFaceID obj element randomID 
                --set the random ID to all faces in the selection
	)
)

The recursive version divides the huge amount of into smaller clusters of faces before setting a material ID.

The algorithm basically divides the amount of faces into halves until the depth value is zero. Then for every subpart the script selects all elements which are connected with the faces of the subpart and assigns a random ID. So the second part is equal to the iterative version.

The only difference is the manner of selecting the faces.

Example for depth = 3

So the number of parts where to set a random material ID is:

Dividing the amount of faces recursively into subparts is very fast. The main bottleneck of this script is the access of the 3dx Max-Interfaces getElement and setFaceID.

The equivalent parameters for iterative and recursive function calls can be calculated by:

Which one is better now?

Basically both version do the same work and should be able to give a comparable result. The main differences are the parameters and the internal procedure.

If you have an object with a lot of polygons and (nearly) every element should have a random material ID then the iterative version will be easier to use because you simply enter 1 or comparable low values for the step size s. or other small values. Then the script would go assignto a random ID to every face and set a random ID. But On the other hand if the elements have a lot of faces the work would often be done more than once. This will be also very slow because of many interface accesses of 3ds Max.

Then it would be easier to use the recursive approach and begin with small values for the depth until you get a satisfying result with enough mixture by increasing the depth value.

Examples

Different material IDs: 3

Duration – iterative

Duration – recursive

It was a pleasure for us to show you these little thoughts about our workflow. We hope you had fun while reading the text and looking to the pictures. To see more of our projects, visit our Showroom.

Der Beitrag Workflow Tips | Random Material ID erschien zuerst auf LEFX.

The next pictures are an example for such this situation. The white area, the distribution map, is nearly 16th part of the black area, which is the distribution object.

Our first thoughts for the project were, to model the environment from a plane and then scatter the different objects like trees, grass and bushes by maps on the same plane. The advantage is that all areas have the same mapping and so it is possible to create the maps easily in Photoshop. Additionally it is easy to create hard edges between different areas, like the dark and the bright grass of the green. In the next picture you can see the different areas for the scattering in the project. Every different color is an area.

Simplified this method -for that article called Method 1- looks like in the next picture. For the distribution object we took the plane with a fit planar UVW mapping. The Multiscatter plugin arrange the objects only in the areas, which are visible by the map for the mask.

At this point of the project we noticed that we have to use a higher count for the quantity of the scattered objects as we could see in the result. And a higher count of objects in a scene is equalized to use more of the memory. For just a few objects -for example just one or two types for the trees- it is not important, but for this project we wanted to reach the limit by using many different types for the trees and the grass. For this reason we tried to find a solution, our method 2.

After some tests we figured out, that Multiscatter first scatter the objects over the whole distribution object and not till then cut off by the map. So Multiscatter creates -in these example- 16000 objects and then cut nearly 15000. So we have a multiplier by 16 for not used objects.

Our idea was to minimize the objects which are not used in the areas, which are invisible by the map. The only way to make it possible is to delete the unused areas. It is necessary that there are some polygons around the white area, so don´t delete them all. The next picture shows it for this example.

The third step, by copying the UVW mapping of the big plane to the new cut plane and not to fit the mapping, is very important. Without this step it isn´t sure, that the objects are scattered at the same part in the scene.

After deleting the unused polygons it is possible to set the count from 16000 to 1000, because the white area is nearly 16th part of the big plane. The following picture shows a comparison of both methods. The distribution objects and the count are changed and the map is the same.

Finally we have decreased the count from 16000 objects to 1000 just by deleting some polygons. In our project we had 6 distribution objects instead of one and for every distribution object 3 till 6 Multiscatters. The next picture shows one of these distribution objects.

It was a pleasure for us to show you these little thoughts about our workflow. We hope you had fun while reading the text and looking to the pictures. To see more of our projects, visit our Showroom.

Der Beitrag Workflow Tips | Multiscatter – How to scatter by Maps for small areas erschien zuerst auf LEFX.