[Closed] The MCG Thread: Post Tools, Compounds and questions here!

My first two proper MCG modifiers! I’m learning fast!

Another simple little plugin. MCG_AttachWorld. This allows you to ‘attach’ an object as a modifier. This means you can turn it on or off, and also this is world-based, so if you move your object the attached object stays where it is in world position, and will also update if it’s animated too! Make the most of max’s modifier stack!

Here’s a simple morph plugin that morphs between one mesh and another. Not uploading it, so if you want to try, you’ve got to make it yourself and learn!

just make simple tool with push compound (which uses pararel combine…). if simple pushing vertexes along normals is so damn slow there’s no need to investigate further

From Clovis.

“Second MCG experiment, with shapes this time
I reproduced two scripted modifiers I did before. Faster results”

[VIMEO]125280097[/VIMEO]

Since performance is back on topic again. How about to try to reproduce some of the tests from this nice ICE and Houdini comparison?
https://frenchdog.wordpress.com/2009/09/12/ice-vs-vop/

It’s interesting to note how their times are very low on most tests. How can ICE be so fast if AFAIK it’s not compiled?

Oh and in addition. If your modifier is getting more complex and complicated, makes the whole stuff more unstable…

That’s not remotely true at all. VEX was originally used as the shading language in Houdini, and has been expanded to fully support modification and creation of points, verts, and polys. You can also modify volumetric data with it. Ice was also very similar in that respect, and used often in rigging.

MCG and Genome are very similar ICE and VEX in what it can be used for, just more limited than ICE or VEX.

And not all tests from the link I posted are particle related. MCG can’t do these but ICE and VEX can do what MCG does. There’s “Test B” for mesh deformation which is pretty simple and I guess a good comparison case since it’s quite reproducible. The “Test D” which uses raycast is also doable, and while we don’t have exactly the same scene or poly count, they at least give an idea how MCG would compare in those cases.

Just a small test, using a MCG mxs function (so avoiding any overheads of mesh conversions).
VectorOperations
100000000 vectors (including the random generation of those vectors)
Average time on my i7 4770 (for 30 runs) 3814ms (run out of memory in the middle so use lower numbers)

Also a small note, the use of ImmutableArrays is a good option when dealing with threading, and you must see that dotnet arrays/lists are just a lists of pointers, so we are just moving pointers not objects, almost everything (except struct’s and strings) in dotnet is passed by ref (aka pointer).

 (
 	sliderTime = 1
	reps = 3
	ops = 10000000
	avg = 0
	for i=1 to reps do
	(
	st = timestamp()
	a =dsVectorOps ops
	avg += (timestamp()-st)
	a = undefined
	gc light:true
	)
	format "average %ms
" (avg/reps)
 )
 

edit: at time zero lots of invalid vectors

And for those that may complain about not visualizing the result.

(
	slidertime = (random 1 100)
	a =dsVectorOps 100000
	m = editable_mesh()
	setNumVerts m (a.count)
	for i=0 to a.count - 1 do
	(
		v = a.item[i]
		setvert m (i+1) [v.x, v.y, v.z]
	)
	update m
	m.vertexTicks = true
)

I’m a little bit dissapointed with the performance of MCG, I’ve made a simple push modifier with animated parameter, on a sphere with 36k vertices I have 0.97 fps on average, the native c++ push modifier on the same object works at ~27 fps :hmm: