Here is a making of.

First find somewhere an animated galloping horse, put it into 3dsmax, find the cycle interval and make a Point cached geometry (thanks polypixel!).

Then “detach” an animated head, tail and mane. This can be done by adding Mesh select and DeleteMesh modifiers after the Point cache modifier. The head is necessary for proper sticks density, tail and mane will be emitters for the digits.

Next make 6 Particle flow systems, 3 for head and 3 for body of each horse. Three systems needed for three different sizes of the sticks. Particles will be gradually born and disappear at the pads below horse’s body and head. Point a couple of thin and tall planes with a lot of height segments as a Shape Instances. For a better sticks animation use the Spin operator with huge Random value.

For a next operations with our particle systems we need to convert them into 3dsmax objects. Use the Mesher compound object for this, point appropriate PF systems and align the coordinates if needed.

Add the Vol.Select modifiers to select the only vertices on the outside of the horses. Then add the DeleteMesh modifier, and finally Shell and Push for the depth and overall width of the sticks.

Make the final run out of the sticks using the Noise modifier (before the Shell in the modifiers stack), rotate it’s Gizmo to fit the sticks orientation and set the animation by the height axis.

For the digits create 10 separate objects with the digits from 0 to 9, center their Pivots and Group. Make three PF systems for the tail, mane and other skin of the horses.

Point proper horse’s body parts as emitters, turn on Animated shape check-boxes, add to the Force operator some wind and kill all the particles afterward the birth within several frames.

As a bonus make the digits running by the horse’s skin surface.

Create two groups with several animated deflectors in them (one deflector for some reason doesn’t affect all the particles), so the deflectors fly through the horse. First group turns on the visibility of the particles-digits linked and oriented by horse’s skin surface. Second group kills particles.

Render and send to Duler.

That seems to be all.

Here is my recent reel.

Hires (100mb)

Most of the works made in SHANDESIGN

As the new year every-CG-artist-nightmare began, here is simple holiday hint.

Let’s steel some bokeh pictures from internet, or take a photo of some bright defocused lights.

Cut them with a circle masks in AE or PS and make an equal images sequence (i did 10 pictures).

Setup the multi/sub object material in 3ds max for 10 ID’s, with additive transparency.

Put the white-to-black gradient ramp texture to the opacity slot using the second UV channel.

Put the bokeh images sequence into the diffuse slots using the first UV channel.

Let’s make the particle flow system based on some interesting complex geometry, e.g. some twisted helix splines.

Set proper number of the vertices in the Birth operator, and also set location: selected in the Position Object operator.

Use Mesh select over all splines to convert splines to mesh vertices.

Add Material Dynamic operator with prepared multi/sub object material to the PFlow event.

Let the Shape Facing operator, oriented to the Target Camera define particles shape.

And now the main part of the tutorial – add the Script operator with the following script:

on ChannelsUsed pCont do
(
pCont.useTime = true
pCont.useScale = true
pCont.usePosition = true
pCont.useMapping = true
)

on Init pCont do
(
)

on Proceed pCont do
(
count = pCont.NumParticles()
tarpos = $Camera01.Target.position
campos = $Camera01.position

for i in 1 to count do
(
pCont.particleIndex = i
pCont.setParticleMapping i 2 [abs((distance campos tarpos)-(distance campos pCont.particlePosition))/500,0,0]
— all the particles get the UV coordinates at 2-nd UV channel here.
— UV coords depends on the distance to camera’s focus “sphere”.
pCont.particleScale = abs((distance campos tarpos)-(distance pCont.particlePosition campos))/5
— here is the dependence of the particle’s scale defined
— “focused” particles are small, as they moving away from the focus – they are becoming bigger.
)
)

on Release pCont do
(
)

This script will define particle’s scale and transparency depends on camera’s focus.
Now you can animate the geometry or the camera and render the particles with scanline.
Don’t forget to cache all the particles for viewport/render using the Cache operator.

This setup renders pretty fast as opposed to mental ray’s or vray’s honest dof.
And we have fast bokeh effect with the ability to inceract with scene geometry.

Here is the scene

P.S. While i worked with the script there were a couple of obstructions, which took several hours to break.
And after finding the proper solution, i found that exactly same solutions were already described at the second disc of CG Academy Particle Flow Scripting.
So if this theme is interesting for someone – i advice to look through. My respect to Bobo!

That is all.

Several different ways to make a dust.

quicktime movie

We need 3dsmax, vray, ae, physx, fumefx, krakatoa, a lot of time and disk space.

0. Simulation with PhysX.

Build a house from simple non-intersected blocks (bricks, ceiling, glass, roof tiling etc.).

Roof frames and other concave objects must be joined into groups.

Make all objects, except the floor, Dynamic RigidBodies, assign them different weights. Set initial speed and big weight for the demolition spheres.

Add all physical objects to the simulation and simulate for 250 frames with Auto Key button enabled. Render with Vray.

Make some hidden noised geometry behind pre-broken glass and push them away at the right moment.

1. Sprites dust with Particle Flow.

Make the sprites system – tons of camera oriented square particles with transparent texture.

Sprites should be born on the hi-speed moving objects and fly with the same direction. Also they should be decelerating and dissolving with age.

Stick a huge amount of particles to all the scene objects, and spawn the sprites from them when the parent particles will have certain velocity or acceleration.

The acceleration sprites will be born at the impact moment, like some clouds beating from parent objects.

Velocity sprites will escort the most active parent objects like a cloudy trails.

Make the dust material for the sprites with a radial gradient mixed with Smoke map for a opacity texture, dissolved with Particle Age.

We should have a lot of particles for an intersection artefacts minimisation, growing with age and then dying.

Make the Drag force for the sprites air decceleration, assign a Matte material for the geometry an render with Scanline.

2. Debris with Particle Flow.

Debris should be made from geometry particles (Tetra). They must be randomly scaled, and rotating.

Add the floor Deflector and a Gravity, kill the Drag.

Render with scanline.

3. Ground impacts dust with Vray, AE, Fumefx.

We need some kind of Realflow wetmap for a ground impacts dust.

First, render a ground Vraydirt map or any other occlusion texture from the top view. Hide for camera (not for render) all other objects.

Blend a couple of rendered texture copies with the Difference, shifted the top layer for one frame in AfterEffects, then precompose.

Blend about 10 copies of this Comp with Add or Screen and Blur them, shifting eath layer for one frame.

So we have the texture, white at the object’s movements near the ground. The texture should be a smoke emitter in the FumeFX.

Set the small Buoyancy and huge Diffusion for a more dusty look.

Render the smoke, lighted with direct light, placed at the same location as the Vraysun.

Add the blue light across the sun, for a more dramatic render.

Turn on the Fluid map before the FumeFX simulation for more detailed dust.

Don’t forget to turn on the Fluid map in Exporting channels, and add some Noise or Smoke textures in appropriate slots.

4. Turbulent dust with Particle Flow, FumeFX and Krakatoa.

Open the velocity Sprites scene and make the FumeFX smoke emitters from all of the particles.

Simulate smoke with FumeFX and save the cache. We need the Velocity channel in the Exporting channels enabled before the simulation.

Make new Pflow particle system, producing 5 millions of particles, that should be born on the scene objects with small random offset inside (to minimise the moire effects)

The FumeFX Follow operator will control particles speed, all we need is picking the FumeFX container wihtin the operator.

Cache all the animation to disk with Save Particles To File Sequence routine in Krakatoa GUI. The cache will take about 20 Gb of disk space.

This pass is very cool, but we need a geomerty matte for the compositing.

So make the Named Selection Set with all the scene geometry inside and point it as Matte Object in Krakatoa GUI.

Push the geomerty outside a little for assured particle coverage.

That is all.

how to make a loopable cloth simulation using 3ds max

1. Simulation

Make a hi-res 2:1 plane, and add some geometry details for the seams.

Choose cloth settings for a whole flag (e.g. silk or satin).

Make two cloth groups – one for a cloth preservation near a flagstaff (with a small soft selection), and another for a heavier cloth at the seams imitation.

Change the seams group cloth settings to a more rigid (e.g. burlap or rubber).

Set up the gravity and a wind with the turbulence. Animate the wind’s direction and strength. For a better turbulence settings control I made a simple particle system and bind it to the wind space warp.

We are ready to run the simulation. You can also play around time scale to make the flag looking magnificent.

2. Point cache

When simulation is over – it’s time to make a point cache from it.

Apply the point cache modifier over the cloth.

Save the cache to the HDD and put the files to the network folder for a distributed render or backburner (For some reason exporting directly to the network folder doesn’t seem to be working).

Now get rid of the cloth modifier from the stack for a file size economy.

Make a copy of cached flag and choose a pair of the most epic simulation parts for a future loop using a playback type – playback graph.

To get a proper loop, the playback graph frame number of the first flag copy in the first frame needs to be equal to the playback graph frame number of the second flag copy in the last frame.

3. Morphing

As I noticed, simple morphing is not enough for a proper looping of the cloth anmation, so for the more natural cloth motion use the “wipe” morphing transition described below.

Apply the Vol.Select modifier to the first copy of the flag under the point cache. Animate modifier’s gizmo motion in the wind direction. It should come over to the flag with a huge selection softness.

Put the morpher modifier over the pointcache and choose the second flag’s copy as a morph target.

Turn on the automatically reload targets switch for an animated result.

4. Wrinkles

As seen on the reference videos there are small wrinkles appears around a seams which are looking good, however we still don’t get them so far.

Simulate the thin cloth stripe with fixed top vertices (selected every second vertex). Add some wind with small strength and huge turbulence.

Render the simulated stripe with self illuminated gradient material applied across and get the wrinkles displacement map.

Assemble looped construction from the rendered stripes and put it to the map slot in the displacement modifier over couple of turmosmooth iterations.

5. Texturing and render

Make the diffuse, bump and opacity textures from the cloth photos in Photoshop.

Make a vray2sided material with a vray material inside. Put the maps to the corresponded vray material slots.

Set up the lighting and render.

These pics (third pic – chupakabrah) and animation were made from a standart max primitives processed by Voronoi algorithm.

Make some interesting geometry in 3dsmax and embrace it in a bounding box.

Export model from 3dsmax to a Wavefront OBJ file.

Open OBJ file in the 3D Object Converter and save as Qhull OFF file.

Get rid of needless part of text information at the bottom, and two digits at the top and save the rest as “points.txt”.

Put the file to Qhull programs folder.

Run QHULL-GO console from Qhull folder.

Run “qvoronoi s p Fv out.txt” command in console.

After the command completion the “out.txt” file will appear to the Qhull folder.

Now put in the same folder the convert3d.py script from the Zoetrope.

For the script to be properly excecuted you must have the Python 2.6 installed on your system.

After the command completion the “out.txt” file should appear in the Qhull folder. Load it into 3dsmax and enjoy.

Btw. Great respect for all af the listed above tools creators.

movie

And the challenge was to shake and mix two fluids of different colors.

Let’s modelin 3dsmax basic primitive like in picture below, kind of a sloped plexyglass figure for shooting beer stuff, and export it in obj format with triangle faces option checked.

Setup in RF an epic collison of two luquids from two different emitters with the rapid of 50.

Next make a single shared mesh for both liquids, with resolution a bit higher than automaticlaly suggested.

Calculate the mesh and import it into 3dsmax, add Relax on top of mesh for extra smoothness.

Render both meshes by order with vray, each with it’s unique materials reflections and refractions from the same camera.

Assign pure self illuminating material to mesh, with gradient ramp texture from white (0-25% [255 0 0]) to black (75-100% [0 0 255]).

For the U axis tiling enter a mystic number 0.05.

Choosing UV coordinate settings, possible by looking at UV-unwrap of the mesh imported from RF.

For example, here’s the settings for three emitter positioned in one dimension.

If enable “show material in viewport” button we’ll see that mixed parts of fluids now have grey color and “pure” parts of every liquid stay white and black respectively.

However, there are very sharp transitions in the areas where two liquids mix, there is a need to blur them out.

Here comes in handy render effect called “Surface Blur” written by Pavel Kuznetsov, for which (and for others,too) megarespect to him.

Render the mesh from the same camera once again with blurred result, without any reflections, refractions etc.

By the way, we can also render v-ray passes for velocity and z-depth channels for compositinig work later on. (unfortunately in combination with surface blur, it’s impossible to get real depth of field and motion blur)

Now, let’s load into Aftereffects all the sequences we’ve got.

Substract one of the main color liquids by assigning luma matte for black and white mask. Put another colorliquid at very beneath, then precompose all.

Make some color corection, DOF and motion blur as a post effects from respective channels.

Thats all :)

P.S. I’m not sure if the same method will clearly work for the mixing fluids into some kind of volume, for that purpose, some further composition work is needed.

P.P.S. Thanks to Polypixel for translating from russian

I’m totally sick about huge overuse of CG lens flares, especially ae knoll chroma hoop and photoshop’s 35 mm.

So to fight with this i thought out cool method to kill a week – shooting to photo camera real lens flares, then combine them to HDRs and track them with light sources in ae.

Take cam with ability to shoot manually (Canon EOS 350D for example), LED light and a dark room without any kids and pets.

After thousands of boring tryouts come up wıth ruqirement of five different exposures for every frame (to compile HDRs) and about 100 LED light positions for enough smoothness of the flare’s movement.

Kiss your wife goodbye for a couple of days and locked myself into the dark room, and shoot there 500 frames, shining out to your eyes with 200 lm tactical LED light (i forgot to warn you – eyes and photo cam matrix will go to trash after all)

To automate shooting process for such a lot of frames use DSLR Remote Pro, it is helpful to remote control photo cam by usb. Set up the time lapse for 100 frames by every 30 seconds and exposure bracketing for 5 frames by 2 steps (by shutter speed)

Go out to daylight and after LED trails are dissapeared from the eyes let’s deal with HDRs.

Install Photomatix Pro for HDRs compiling, this software has an ability to automatically recognize EXIF info from shooted JPEGs. So feed to Photomatix all the JPEGs and go to bed. by mornig you will have 100 HDRs

Now it’s time for ae.

We have to figure out some kind of a system for motion of hdr on the screen. Lens flare basic feature is aperture ghosting, that moves opposite to light source by the center of the frame. So use the tracking method which covers this kind of movement.

To implement this scheme you’ll have to recall some basic trigonometry knowledge from school, particularly arc tangents and sum of the squares of the legs.

Do not forget to switch to 32-bit mode in ae for proper work with HDRs

Make comp 100 frames lenght, lad HDRs sequence and named it “photo-sequence”.

Make another comp with two previous comps layered and add null named “target”. Dimensions of this new comp should be one and half times less than comp with “photo-sequence”.

Enable time remapping for “photo-sequence” layer and use folowing expression:

x = thisComp.width/2 – thisComp.layer(“target”).transform.position[0]
y = thisComp.height/2 – thisComp.layer(“target”).transform.position[1]
Math.sqrt(x*x + y*y) * ((comp(“photo-sequence”).duration / comp(“photo-sequence”).frameDuration) / (comp(“photo-sequence”).width / 2)) * thisComp.frameDuration

For rotation of the same layer use this one:

x = thisComp.width / 2 – thisComp.layer(“target”).transform.position[0]
y = thisComp.height / 2 – thisComp.layer(“target”).transform.position[1]
z = 0
if (x > 0) {z = 180}
radiansToDegrees(Math.atan(y / x)) + z

Now if we move “target” – HDRs flares follow it. Notice, that we have a lack with the rays when “target” moving around the center of composition.

If you need to use true 32-bit motion blur it will be heplful to apply “Echo” effect for HDRs comp.

Finally track some CG light sources, applied tracking data to “target” position and link flares exposure to CG lights brightness.

All we need as a final step is to track any CG lamp, insert keys to position of “target” null and adjust exposure of the flares.

After days of shooting and boring hdr’s combining you could obtain a library of ajustable real lens flares

Anyway, great respect for Knoll Light Factory team!

this is the web, made with cloth modifier

large picture

1. straight to web modeling. first we’ll make spline spiral, with radial crossections, then damage it a little for more realistic look.

2. extrude our spline with a huge amount, but without caps

3. convert extruded spline to editable mesh and weld vertices

4. apply subdivide modifier, to break the web into big amount of segments. this operation needed for bending web lines.

5. select open edges and make spline from them

6. let’s make geometry from our spline. turn “enable in viewport” option at the “rendering” rollout, we need thin rectangular with 45 degrees angle.

7. and finally weld vertices at the web corners

8. now it’s time for drops. we’ll make them with Particle flow system

9. to begin with, create small geosphere with 2 segments

11. select only bottom vertices of the web mesh

11. set the particle system

12. turn particles to mesh with mesher, and attach them to the web

13. weld top vertices of the drops with bottom vertices of the web

14. apply cloth modifier

15. start simutation and go have a lunch

16. when come back – take last simulated frame and convert to editable mesh

17. apply some nature HDR map to environment and glass material to the web with drops

18. render with vray, add some posteffects in ae

That’s all