Week 18 – Sparks and Fire for Going Live continued, Focus Groups assignment, Reflection on Practice

So, this week continues with the lessons on creating sparks and fire, for the purposes of creating fire for the dragon in Going Live. We begin again at lesson 8:

Lesson 8 – Establishing our Final Shot

• To make the scene more realistic, add a point light inside the meter and key the intensity of the light in conjunction with the keyed sparks – so, in my case somewhere between frames 29 and 39 initially, then frames 60 and 70 [Image 1]

• You need to set the decay rate appropriately so that the rest of the scene isn’t getting lit by the light – in the lesson he uses linear, but you could use quadratic if you were using real world size
• If you want to customise the glow, select the shader glow from the hypershade and adjust the glow and halo attributes, but remember you can change this in the comp anyway
• Also, for both the child and parent particles, in render stats attributes, make the ‘visible in reflections’ box active for the reflections in the pool of gasoline [image 2]

• Go to solvers, create particle disk cache – give the directory and name and create

Lesson 9 – Blocking Out Simulations

We’re first looking at the aesthetics of the flames via a YouTube video for reference. Colour-wise, from the bottom it starts with a yellow to orange to black smoke and the fire itself spreads very quickly. We’ll be using 2D fluid containers in Maya to represent this.

• From the fluid effects menu, create a 2D fluid container, use a 40 x 40 resolution to begin
• Remember, a 2D fluid container has X and Y size but also a Z depth of 1 voxel unit (volumetric pixel) – density, velocity, temperature and fuel are the important attributes
• In Maya there are 3 types –non dynamic; dynamic; and ocean and pond – we’ll just be looking at the dynamic for these lessons
• The fluid is emitted by an emitter or an object that initiates it
• Split your scene up into render layers: fire layer; reflections; spark; bg_layer; masterLayer
• Change the fluid containers X value to 18

• With the container selected, go to fluid effects menu, add/edit contents, emitter – options box
• Set the emitter type to volume – volume shape sphere – apply and close
• Remember – you need to keep the emitter inside the container, otherwise no fluid will exist!
• Drop it down to the bottom of the container – when you run it, the fluid is very low res – change the fluidshape container properties to ‘keep voxels square’ and set the base resolution to 250 [image2]

• Only other thing is that you can tumble the camera around a 2D fluid emitter – it’s flat!
• Select the fluid emitters attributes – set the turbulence to 2.5 and the detail turbulence ( a multiplier of the turbulence) to 1.5
• Reduce the fluid drop-off to 0, so that the emitter retains its shape and size [image3] – you can also see the cause of the turbulence more now as well

• 3 basic nodes in 2D fluid – transform, the shape and the emitter (and time)- we’ll be focussing on 2 attributes, the density and the velocity
• In the fluidshape node – change the (dynamic simulation) damp attr to 0.1 – this controls the velocity of the emitter and the instability to slow it down a little
• We’ll stick with the navier-stokes solver (used for fluids, air and gas – ‘spring mesh’ for ocean and pond)
• High detail solve – set this to ‘all grids’ as it will provide a higher detailed simulation
• Next the density parameter (below contents details) which is the most important attribute to block out the fluid – here density represents a ‘material’ attribute
• So, set the density scale to 0.65; buoyancy to 10 (positive goes up, negative goes down); dissipation to 2 (how it fades); gradient force to -60;
• Velocity – set swirl to 8
• Turbulence – don’t get confused with the fact that there is also a turbulence attribute for the emitter, whereas this is for the fluidshape – set strength to 0.25
• Scale the emitter along the Z axis to make it longer and check out the changes [image4]

Lesson 10 – Placing our Fluid and Fluid Emitter

We’re going to look at the shading of the fluids here:

• First though, return the scale to the previous size
• Fire carries its own incandescence and glow etc., so we’re not using the color attributes – switch the color to black – so under shading tab – switch selected color from white to black – leave color input at Constant
• Incandescence – change the Incandescence input to density as this is driving the colour
• Opacity – (should be set to density, if not do so) then open up the opacity graph and make settings as seen in the image below [image 1] NB – little tweaks to this graph can make a huge difference to making realistic flames!

• Go back to the incandescence graph, make sure there is a white swatch color at the end, set the Interpolation to smooth [image 2]

• Under the shading tab, reduce the transparency a bit more on the slider, glow intensity to 0.1, edge drop-off to 0.015
• Test it to check the colours – if it’s too orange or whatever, move the incandescence sliders to bring in more white et from the right and slide them to the left
• Scale the emitter again along the X axis just as a test to see how the flames are looking [image 3]

• Tweak the opacity graph to see the difference it can make! [image 4]

• Shading quality tab – render interpolator set to smooth (improves on jittering artefacts) – although for now, keep it at linear as it blurs the render
• Return the scale to 1 again
• So, now we want to check when  the sparks hit the gasoline so we can key the emitters density attribute
• At frame 1 set the fluid emitter density/voxel/sec value to 0 and set key – same again at frame 70
• At frame 90 set it to 1.25, set key (that way it will build up overtime)
• For the X value of the scale attribute – set keys at 0 and 70 for value 1 – then at frame 120 set it to a larger spread out value [image 5]

• Move the emitter to the left slightly so it comes intocontact with the oil can – we can make it collide as well–select the fluid, ctrl select the oil can, fluid effects menu, make collide – options – tessellation factor of 500 is fine – apply and close
• We’re going to up the turbulence strength to 0.35 (fluidshapenode)
• Increase the timeline to 200 frames
• Select the fluid and create another emitter – place it on the right of the fluid and scale it out from the start – density set to 1; fluid drop off to 0.25; turbulence set to 3; detail turbulence to 2;
• Again, need to set the keys for it – set keys at frames 0 and 80 for 0 value of voxel density; frame 120 a value of 1, or whatever you fancy!
• Test render! [image 6]

• Don’t worry too much about the colours as we’ll do that in post!
• You could change the gradient force to -100/-80 for more force if you want (density)
• For a better render, turn on ‘visible in reflections’ [image 7]

• Next up, smoke and render layers!

Lesson 11 – Creating Smoke

So, before we get around to adding the smoke in, there are a couple of changes to note:

• Add in another emitter in, the same way that you did the last one to expand the fire further [image 1]

• Add in a uniform field – magnitude 25, attenuation 0, direction Y 0.5 (upwards slightly), direction Z -1 (towards the barrel)
• Change the opacity graph slightly to get rid of any soft smoke, as we’re going to be adding in the smoke separately [image 2]

• NB – lambert materials with the Matte Opacity setting of ‘Black Hole’ have been applied to the background geometry to make it visible in the layers with other elements, but it doesn’t render – Black Hole doesn’t receive any shadows, but ‘use background’ utility does
• Add in a new fluid container (about double the height of the first and a little wider) with an emitter about half the height of the barrel and slightly shorter than the fire emitters.
• Container – Base resolution 150, size 20 x 20 x 0.5 (boundary Y, -Y)
• Emitter – volume, cube shape – fluid attr – Fluid Dropoff 0
• Fluid emission turbulence – turbulence 2, turbulence speed 0.5, detail turbulence 1,
• Key frame the density attr – 0 up to frame 60, then up to 1.25 at frame 130
• For the fluid shape, the dynamic simulation attr – high detail solver is off, damp to 0.1, Density set the buoyancy to 10/15, dissipation 1.5/2, density pressure threshold 1, noise 0.05/0.07, gradient force 80
• Velocity – swirl set to 8/16
• Turbulence, strength set to 0.2 (freq and speed 0.2)
• Shading – transparency dark grey, drop off shape –Y gradient
• Incandescence– color white (we’re going to invert it in post) input – density, Input bias 0.361
• Opacity input – density, input bias 0.2 (shows more smoke upward!), interpolation spline – see the image for graph [image 3]

• Shading – transparency dark grey, drop off shape –Y gradient, edge drop off 0.5 (you don’t want the smoke to lie on top of the flames too much, otherwise it will block/black it out
• When rendering, you may want more or less detail in the smoke – if you increase the Z container property size to 1, the smoke will appear thicker/more dense, therefore, less detailed

To set up the render layers:

• Bg_layer: for this layer, use only the key light and bulb light (filter out lights only in the outliner – rendered only a still targa image as it’s the same all the way though the scene! For the other lights, you need to render the animated lights obviously!
• Spark layer: the particles are cached for this layer, so they are applied as well as the bg geometry – lambert shader mentioned above with black hole matte opacity and a brighter colour for reference only – could also use the ‘use background’ utility with specular colour set to black, reflectivity set to 0, reflectivity limit 0, but remember ‘black hole’ receives no shadow
• Fluid reflections layer: add the fluid container, but under render stats switch off primary visibility (override – turns orange) and turn on ‘visible in reflections’ and ‘visible in refractions’(override – orange again) Also need to add in the base floor, so you have something to image the reflections on [image 4]

• Fire layer: fluid separately!
• Light fire flames layer: 3 separate point (omni) lights with decay set to linear, intensity set to 2, orange in colour (or white if you choose to tweak in post) – ray traced shadows with light radius 1, shadow rays 8 – also bg geometry
• Flash light layer: animated point light for the meter we set up earlier – also bg geometry – NB – hide all the other lights!
• Flash fire layer: another point (omni) light with creation expression attributes in the intensity attribute (same initial attributes as the other ‘light fire flames’ lights – [see image 5]

• pointLightShape4.intensity = rand(3,6); – also bg geometry. Again, hide all the other lights!
• Spark reflections layer: same idea as the fire reflections – switch off primary visibility and turn on the visible in reflections [image 6]

• Smoke layer: the smoke fluid with no reflections [image7]

• can do bg with black hole assigned if you want!

Here’s a render with all the elements in place – however, the smoke will be black rather than white in the final composite.

Lesson 12 – Creating the Final Composite in AE

So, the final lesson in this series looks at the composite using After Effects. The same kind of thing can be done using any similar tool, so I will no doubt try it in Nuke.

• Start off with the background targa image as the base image (the basic diffuse layer) – normal blending mode
• The next layer up is the point lights targa to highlight the fact that the fire has started – key frame the opacity levels to come up as the flames grow – screen blending mode
• Further up the stack above the sparks layers (next) we have 2 versions of the fluid fire and reflections (doubled up to increase the effectiveness), also a Gaussian blur for some soft glow – both using Screen lending modes
• So, above the combo lights layer we have 2 sparks layers, similar to the fire above, doubled up with a little Gaussian blur – screen blending mode
• Next up we have the sparks reflection – screen
• Next up the meter light to support the sparks
• Next up is the flashing fire light – screen
• Lastly, the smoke – invert – multiply blending mode
• In AE, you can create a pre-comp layer (select all layers – CTRL Shift C) – then duplicate this layer and use a different blending mode – he uses Overlay, but it depends on the look of the scene you’re creating of course! (You can use the opacity setting to control how much you want)

My version is slightly different! [Image 1]

Reflection on Practice – Focus Groups and Interview Assignments

Wednesday of this week was the hand-in for the first assignment for Reflection on Practice, which involved the creation of a plan for a focus group related to our research. The idea was straight forward enough, but when it came to constructing questions for the audience, I realised that: first of all, I didn’t require the help of the general public, but a more academic group of scientists from different backgrounds who could offer opinion based on their own experiences; and secondly, the questions needed to be geared toward input from their own experiences.

The second assignment is the realisation of this focus group, or a one to one interview with someone outside of the College who can offer an alternative view of my research. In doing so, the idea of involving a deaf/blind charity in my work seems like a good idea, both in terms of the potential benefits for the hearing impaired to feel and ‘see’ sound, but also in terms of the fact that it focuses my own research in on a particular goal, rather than the vague ‘entertainment’ or ‘education’ tags that I have thus far assigned to the title.

I have sent an email to Sense Scotland, who run a centre called ‘Touchbase’ in Glasgow, who will hopefully grant me an interview and we may be able to help one another out. I will update the outcome of this shortly.

Going Live – Fire Test

As well as the dragon head I built for rendering tests, I have suggested/been asked by the team to to a fire test for the purposes of showing Axis animation, at this early stage, what we mean to achieve, by means of producing more than we need to for the first hand-in date next week (specifically for the animated storyboards).

So, using what I learned from the sparks and fire lessons, I have put together a rough but hopefully effective few seconds of animation with the same dragon head I designed along with smoke, sparks and fire coming out of its mouth. I created a very simple IK rig for the head, and used a separate joint to rotate the jaw slightly when it opens its mouth to breathe fire. Here is a couple of images from the basic render:

I’ll do a proper render next week with appropriate render passes, lighting, some textures, a basic backdrop and a basic composite.

Friday 31st January – 3D Tracking – Jin

3D tracking was first used by the miloitary in the war to track aircraft and so on. 2D tracking involves X and Y co-ordinates, whereas 3D has all 3 axes. 2D tracking is used  mainly for helping rorplates or creating clean plates. 3D tracking is essesntially for creating a virtual camera.

So, as I have covered the basics of 3D trracking a few ago, I won’t go into great detail here. I will, however, point out some important points to remember:

• step 1 – take off lens distortion! Typically, professionals will ask if you have cropped an image (with lens distortion still apllied) which will essentially create a bad track, and make your 3D life a misery! You don’t want to be modeling on a curved grid!
• So, in general, you take the rendered CG footage and add back in lens distortion to match with the original footage
• in the raw footage, look out for moving objects (like people etc) and reflections etc for tracking
• create a roto node and key out the moving objects
• connect the roto to the mask of lens distortion
• for the lens distortion node itself – image analyse tab – analyse sequence (default) – moving bodies give you a bad result so use the mask – mask – mask alpha (no alpha in the original footage)
• VFX supervisors need to know camera information – what kind, height, distance etc
• Lens D – you also have grid analysis – this is the best option – plug in a photo taken with the same camera
• Line analysis – drawing mode on – you draw several ‘horizontal’ and ‘vertical’ lines along objects in the scene – RMB – you can also delete last point or line
• so, the camera tracker goes under the lens D, tracking tab – the number of features recommended is 250 – the default is only 150 – can maybe use more if you like – 300!
• Track features
• Solve camera
• Refine tab – never used it before but it’s straight forward – solve error – change the sliders at the bottom and dismiss what you don’t need etc
• Solve camera button again
• Create scene – tracker tab
• If you want to see the scene in 2D you need to add a scanline render node
• You can set your ground plane by selecting a group of points on the floor – RMB – set to X axis
• Add in geometry to the scene – connect to scene
• Remember to use lens distortion – undistort box – before merging with the original distorted footage (just copy and paste the first one)
• Exporting to Maya – writegeo node – you can use a mergegeo node before that in the chain if you have several objects – or you could just use the one and export out whatever you check in the boxes
• Write out footage without distortion for Maya!
• Refer to Jin’s files for more detail!

Advertisement

Week 17 – Particles (final fireworks lessons), Creating Sparks and Fire for Going Live, Rigging Intro, Reflection on Practice

Lesson 17 – The Burst and the Spiral Particles

We’re going to modify the emitted particles here to create a spiral effect, intended as a brief flash to bulk out the initial burst and make it look more interesting.

• Change from points to streaks
• Add attributes for current render type – turn on color accum – tail size of 10 (it’s exaggerated but we’ll tone that down!)
• Reduce the conserve of the particles to 0.9, to reduce the tail size after the initial burst as though they’re fading away quickly (general control attr)
• Lifespan – random range
• NB – an important number to remember when calculating the length that you want a particle to last, can be worked out by first typing in ‘print (1.0/24)’ in the MEL script line. You’ll get the answer on the bottom right of the screen, so here it’s 0.041667, or ~0.042. If you had a different frame rate, change the equation to suit! So, if you want the burst to last 2 frames, it would be 0.084 (or 0.8 is fine!). This value would be typed into the lifespan attribute, while you can make the lifespan random 0.4.

• Add a per object color attribute and make the RGB 1 each for pure white or 0.3 on the blue channel to make them slightly yellow
• Add opacity (add dynamic attr)to add more variation – per particle attribute – creation expression as follows:

spiralBurstShape.opacityPP = rand(0.1, 0.5);

• We need 2 more particles now, so you can type in ‘particle’ to the MEL script command line and enter, for the first
• Rename ‘spiral’, parent under the spiral group
• Select ‘spiral’ and emit from object to  create the 2^nd particle – rename ‘spiralTrail’ and parent under ‘spiral’ as well as renaming the emitter ‘spiralTrailEmitter’

• Open the expression editor to edit the spiralShellShape runtime after dynamics expression that we left as ‘to be completed…’:

emit -pos ($pos.x) ($pos.y) ($pos.z) -at “velocity” -vv (rand(20, -20)) (rand(20, -20)) (rand(20, -20)) -o “spiral”;

• So, the particles are being emitted with the trail behind them – next thing is to tweak them!

Lesson 18 – About Spiral Motion

A little offshoot lesson explaining the motion circular motion from above combined with the up and down Y direction, which results in a spiral motion.

• To cycle curves – open the graph editor,  select the curves, curves menu, post infinity, cycle
• Also, add a motion trail from the animate menu.
• So, overall the direction is up and down (y axis), and the direction of the spiral is perpendicular to that direction (the x and z axis)
• So, to return to the scene, select the spiral particle and reduce the conserve to 0.975 (so it’s supposed to be slowing down in the atmosphere a bit)
• Shift select the air field, go to the fields menu, affect selected object – this will give it some drag downwards but not accelerate the particles in the same way gravity would

• Change the lifespan to random range – lifespan of 1.2 and random value of 1

Lesson 19 – Making the Particles Spiral

Next up, make the particles spiral! To achieve this, we’ll need to add some attributes:

• Click the add general attributes button for the spiral particles (add dynamic attr)

• Call it spiral
• It’s a vector type
• Per particle attribute
• Don’t need an initial state
• Click OK
• Add another – this time called ‘offset’, a float type, per particle, no initial state, click ok!
• Before we do anything else, we’ll try to reduce the initial speed as they almost travel outwards in a straight line before arching toward the ground. So we need to back into the expression editor, select the spiralShellShape runtime after dynamics

emit -pos ($pos.x) ($pos.y) ($pos.z) -at “velocity” -vv (rand(-15, 15)) (rand(-15, 15)) (rand(-15, 15)) -o “spiral”;

• NB – I had the values the wrong wat around before, although it didn’t make much difference, but now they should be -15, 15 rather than the positive value first! See the image for the updated expression if in doubt!
• Try changing then conserve again to 0.985 to give them a slightly longer feel
• So, now it’s time to start adding expressions the sprialShape node
• Start with a creation expression from the ‘mass’ attribute as follows:

.mass = rand(0.7, 1.3);

• This will add some variation to the way the particles fall. Then add the script for the spiral motion:

.spiral = unit(cross(.velocity, <<0, 1, 0>>));

• So, doing this won’t be enough to create a spiral motion just yet, we need to create a runtime before dynamics expression as a start, as follows:

vector $dir = unit(.velocity);

float $speed = mag(velocity);

vector $spiral = rot((.spiral), $dir, (frame));

.position += $spiral;

• We get some very large spiral patterns here, not quite right yet, but we’re going in the right direction!

Lesson 20 – Tweaking the Spiral Motion

• Add in the following script to the expression:

float $amp = 0.1;

float $freq = 2;

//update the next line to this:

vector $spiral = rot((spiralShape.spiral * $amp), $dir, (frame * $freq));

• So, this is better, but the particles start off quickly and slow down which makes the spiral stretch firstly then become more tightly coiled as time passes. Be aware that the trail particles are not doing anything as yet apart from sitting still, which is useful for us to see what effect the spiral particles have at the moment
• We want the particles to lose energy as they fall, so there should be less of a spiral as it tapers to a cone type movement. So to update again:

float $amp = 0.1 + 1 * linstep(5, 50, $speed);

float $freq = 2 + 1.5 * linstep(20, 50, $speed);

• It’s better, but we should reduce the size of the trail particles to allow us to see the results more clearly – add attributes for the current render type and reduce the point size to 1
• Update the expression once again to reduce the initial value of the $amp from 0.1 to 0.03 (reduce it by 1/3^rd) – this looks far better! (see the lesson 20 update3 image for clarity)

• Lastly here, we want to add some randomness to the offset for each of the rotating particles – they all look l;ike they’re rotating at the same time here. So, open back up the offset creation expression and change to(remember the value is measured in radians – 3.14 in half a circle!):

.offset = rand(0, 6.28);

• See update part 4 image!

• Not done yet! Then go back to the runtime expression and add the offset in as follows in image update 5!

Lesson 21 – Falling Behaviour and Colour

• First off, link the spiral trails into the air field
• Select the trail emitter and set the basic emission speed attr – speed 0.5, speed random 0.15
• The air field drags the middle particles down too much while the shape of the spiral is lost a bit due to the speed – we can sort this out by adjusting the conserve – change it to 0.97 (spiralTrailShape)
• Also change the lifespan to random range – lifespan 1.5 or 2, random to 1
• (1st change image)

• Add opacity attr – add per particle (add dynamic attributes – spiral trail)
• Create a ramp
• Get rid of the middle swatch, move the bottom white one up to just below halfway
• Go to the output connections and set the max opacity value to ~0.4

• Next thing to do is to make each clump of trails a different colour!
• Add color attribute, per particle
• Also add a general attr – parentId – so that each emitter has its own Id for colour purposes
• We know from the spiralShellShape runtime after dynamics expression that each shell emits 40 particles – so the first 40 would be numbered 0-39, the second 40-79 etc…
• So, create a creation expression for the rgbPP attribute as follows:

int $group = .parentId / 40;

if (($group % 2) == 0)

.rgbPP = <<1, 0, 0>>;

else

.rgbPP = <<0, 1, 0>>;

• So if it’s even it’ll be red, if it’s odd it’ll be green
• Ok, but to make this more sophisticated we’ll change the expression by introducing  new variable or 2 to control the colour – try you own values if you like:

//The offset will determine the initial value before adding the 0.15 value. [0.05 – 0.15 is closer to //the red/orange section of the spectrum, whereas 0.5-0.65 will be more purple.

int $group = spiralTrailShape.parentId / 40;

float $colOffset;

if (($group % 2) == 0)

$colOffset = 0;

else

$colOffset = 0.5;

float $hue = rand(0.05, 0.15) + $ColOffset;

float $strength = rand(0.8, 1);

float $value = rand(0.7, 1);

.rgbPP = hsv_to_rgb(<<$hue, $strength, $value>>);

• If you wanted more purple you could up the collOffset from 0.5 to 0.7

Lesson 22 – Caching the Simulation

We’ll start this one by re-enabling the ringshell ‘is dynamic’ within the general attributes, and set the emitter to 3/sec for now. The sipralshell, we’ll set to 2/sec for the moment.

• One problem here is that the emitters are detonating at the same point in space, as they’re the same size and shape etc, so we need to rectify this
• We can do this by accessing the ‘emission random stream seeds’ attribute and changing the value – so I’ve chosen the one for the spiralshell, and change the value to 2 (it doesn’t make any difference if it’s a large number) [lesson 22 image 1]

• Some final tweaks in the overall look – the spiral particles are a little small, so we can up the speed of the burst from within the spiralshellshape runtime after dynamics expression:
• Change the ’15, 15’ values to ‘-20, 20’, and also up the conserve value slightly from 0.985 to 0.99 [lesson 22 image 2]

• If you like you can also reduce the ring particles a little, using the same values but reducing them (I reduced the ringshape particle conserve to 0.975)
• The ring trail particles are a bit large, so we could reduce the point size down to 1 from 2 [lesson 22 image 3]

• Lastly, before caching it out, we’ll increase the emission rate of the spiral trail emitter from 100 to 300 to thicken it a bit
• Now, go to the solvers menu – edit oversampling or cache settings – check you have the oversamples set to 5 (remember playback rate is 0.2)
• That being ok, go to solvers menu – create particle disk cache – in the dialog box, name the directory and make sure you select the ‘All’ button for particle systems to be cached [lesson 22 image 4]

• Once this is cached, you can scrub through the scene and check for any last changes. For example, reduced the original ring shell size (it was bigger for the purposes of working with them) – tail size to 1, line width to 1 – do the same for the spiral shells! (you could also add opacity if you wanted as well)
• Because these are object level attributes and not per particle attributes, they don’t need to be reached to see the updates!

(My computer can’t handle the cache!)

Lesson 23 – Rendering the Scene

• Set a frame where all the particles look good together – e.g. 125
• Open up render settings – Maya hardware renderer we’re using
• Start with the default presets
• Name – finalFireworks; name.#.ext; tiff (tif)
• Start frame 50 – end frame 150
• Frame padding 4
• Rendercam
• Try image size as 1920 x 1080 – sometimes when using hardware renderer, it’s better to render bigger then shrink it down
• Don’t need the default light – they’re not responding to illumination
• Leave the hardware settings at default for now
• Try one frame first to try out
• Maybe up the image size to 3840 x 2160 – however, you can lose some of the smaller particles when you do this! For example, in the ringtrail particles – we can sort this out, however, bu looking at the opacity of these particles:
• Remember they are controlled by a ramp, so we could up the value of that by – ringtrailshape pp attr – RMB over opacityPP – edit array mapper – change the max value up to 1 again
• Re re-render – you don’t need to re-cache because it’s being controlled by a ramp
• Save your file – batch render the file
• Can view in fcheck – may want to add a motion blur?
• It might look a little ‘spindly’ due to being an oversized  render, but we can take care of that I the composite

Lesson 24 – Creating the Comp

In After Effects!

• Read in the files
• He has the size here at 1280 x 720 (?) and the frame rate at 24 fps
• RMB over the footage – interpret footage – main
• in the pop up box – assume this frame rate – 24fps
• drop into the timeline
• RMB – select blending mode of ‘Add’
• As far as the size of the rendered footage goes – RMB – transform – fit to comp
• CTRL + D couple of times so that you’re ‘adding’ the same footage which enhances the colour

• Zoom into 100% scale so you can see what’s going on
• Hide top 2 layers, add a glow (stylize menu – or type it in)
• Glow threshold 70% (anything above 70% brightness is going to have the glow applied to it)
• Intensity to 20 (very saturated)
• Glow colors – original colors too saturated so choose A and B colors (black and white) – color looping option choose B-A-B ( this pushes the glow out towards white for the hottest and brightest areas)
• Hide that layer and focus on the middle one now
• Add another glow
• This time, threshold of 40
• Glow radius of 10, intensity of 5 – more of the glow happening over larger areas of the image
• We’ll leave this glow on the original colours as we want some of the saturation to affect the final image, but because it’s a bit too much we’ll add a hue/saturation effect (from color correct) to this – reduce the master saturation to -30
• So, the effect of the glows has softened the whole look, but with the addition of the original final layer, it sharpens the look again
• Select the 2 glow layers – we’ll reduce the opacity as it’s still a bit intense – T is the hotkey to open opacity in AE – try 60% to knock back the glow a little bit
• Maybe set the lower glow to 70 and the upper one to 50, just to tailor it a bit more
• Add to render queue!

 

Tutorials for Going Live

Although I have just completed the fireworks lessons and will put the knowledge to good use, due to the arrival and nature of the going live project, I’m now going to look at a series of lessons on how to create realistic fire and sparks, bearing in mind my role with VFX in the creation of a dragon.

Lesson 2 – Creating Realistic Fire and Sparks

Typically lesson 1 was the introduction for the remaining lessons, so to begin with lesson 2:

• First off we have the scene set up with some electrical meters on a wall overlooking some oil drums. The sparks will emit from the faulty meter igniting the oil below. So, let’s create an emitter (using regular dynamics) and call it ‘sparksEmitter’, make it a volume emitter in the shape of a sphere
• Place it inside the faulty meter
• At the moment, the emitter isn’t emitting the way we want, so let’s change a few things – use the channel box here – away from centre to 5 (Volume speed attr); NB – in the attributes box, ‘away from centre’ is greyed out but not in the channel box! So, change away from centre to 0; random direction to 5
• Rename particles to sparksParticles and set to streak, line width 2, tail fade 1, check the use lighting box! [image 2]

• Select the particles, fields, gravity
• Select the gravity and change the magnitude to 25 to make it fall more quickly
• To make the particles collide with the floor, ctrl select the particles first and then the base floor, go to the particles menu and ‘make collide’ – set resilience (bounciness) to 0.350, the friction to 0.250 and the offset (how far off the floor) to 0.05 [image 3 updated]

• We want the particles to split into 2 or more particles
• Set lifespan to random range – lifespan 3, random 2
• Also make the particles collide with the meter in the same way
• Rather than PP expression, we can select the particles and open the particle collision event editor (particles menu)

Lesson 3 – Particle Collision Event Editor

In this short lesson, we’re looking at the possible ways in which to emit or split particles when they collide with an object. Looking at the graphic below, you can see there are options to trigger the event based on collision number or all particles. We’ll use all for now. They can emit or split and you can choose whether the original particle dies or not. In this case we’ll split it with 5 particles with the inherit velocity of 1 equal to the velocity of the parent particle – create event! [Image 1]

Lesson 4 – Controlling Physics

• Rename things appropriately. So, sparksParentParticles and sparksChildParticles
• Rather than emitting 5, change it to 4 after the split
• To provide the child particles with the same attributes that the parents have, open window – relationship editors – dynamic relationships
• So, you select the particle on the left, and on the right hand window, highlight in blue the attributes that you want to affect the selected element – you have access to fields, collision, emitters and all [image 1], then close the window

• Change the child sparks lifespan to random (3, 2) and streaks again as before, turn on use lighting
• Now we’ll key the rate of the emitter using these value: frame 0 rate 0; frame 20 rate 0; frame 30 rate 25; frame 35 rate 25; frame 36 rate 0; frame 50 rate 0; frame 60 rate 15; frame 70 rate 15; frame 75 rate 0
• If you’re not happy with the rate you can select the rate in the attr or channel box and open up the graph editor – select the keys and drag them up to a higher rate [image 2]

• Turn on the high quality viewport and lighting and do a playblast to check it

Lesson 5 – Looking at the Aesthetics of Sparks

We need to be aware of the look and aesthetic of the sparks in terms of how to shade them:

• By looking at few examples, you can see that the sparks are irregular in size, fade out, are incandescent – they have their own glow and shading values.
• The tail size is controlled by the velocity of the particles

Lesson 6 – Using Software Render Particles

Maya has hardware and software rendering for particles, and ‘streaks’ are also supported by mental ray.

• Select the child particle
• Change the particle type to tube
• Here there are 2 radiuses – change both values to 0.04 (check in the wireframe view to see if you like!)
• Do the same for the parent particles but make the values 0.05 and 0.04 so the initial values are a little bigger
• These particles have a default shader applied called ‘particle cloud’
• We’re rendering in mental ray!
• If you look at the attributes of the shader you can see there are a number of attributes to help us get a decent render [image1]

• We need to use some PP values to control the brightness of the particles based on their age – the self-illumination property is supported by the incandescence, so first select the parent particle and go the PP attributes – select general button – particle tab – incandescence PP [image2]

• Create a ramp – edit ramp
• Change the colours from bottom up to be – white/yellow – white/more yellow – orange [image3] – change the interpolation to smooth – you can also control this in post-production to a certain extent!

• Now for opacity – click the opacity button beside the general button – add pp attribute
• Create a ramp – edit ramp again – delete the middle swatch and change interpolation to smooth, move the bottom swatch up to the middle or so [image 4]

Lesson 7 – Building Shading Networks

• Create a new particle cloud shader from the Maya volumetric shaders
• Select both the child and parent particles and assign the shader to them
• When you open the inputs/ouputs you can see the shader is connected to the child and parent particles, but as yet we haven’t assigned the PP attributes to the child particle, so do the same – create an incandescencePP attribute – create ramp – options – assign ramp 1, so you don’t have to recreate it!
• Same thing for the opacity ramp – assign ramp 3(!) to the opacity per particle attribute [image1]

• If you do a render, the particles are not visible! Set the particle cloud attributes similar to the image below: [image2]

• Ok, it looks fine, but we’re still not using the PP attributes that we set up for the age of each particle to drive the colour etc. How do we do it?
• Go to the hypershade and select utilities – particle sample info (particle sampler)- it’s meant to act as an intermediary between the PP attributes and the shading attributes. Drop the particle sampler info ode onto the particle shader – MMB – other – choose the IncandescencePP on the left channel (sampler) and the incandescence of the particlecloud2 node on the right [image3]

• So, when you close the window, to can see that the particle cloud shader has the particle sampler info controlling the attributes [image4]

• So, now we can switch the color back to black on the particle cloud 2 shader
• Leave glow intensity at 0.5
• Transparency? Opacity is the reverse of transparency – opacity value 1 is fully visible (at the time of birth) – so the transparency value 1 would be invisible – also, transparency is 3 channel based, while opacity is only 1 channel!
• Add in the ‘reverse’ utility
• Formula – opacity = 1 – transparency, or Output = 1 – Input
• So, drive the single channel value of opacity into the 3 channel value of the input node of the reverse, and that input node will act as the output for the transparency – we have control!?
• So, select particle sampler, MMB over reverse, select other, select opacityPP (single channel) on the left and select the input ‘+’ sign on the right and select all 3 x, y and z channels to connect them [image5]

• Now select reverse, MMB drag over particlecloud2 and choose other – select output on the left and transparency on the right [image6]

• Now do another render and compare – the new render should carry a variety of white to orange colours depending on the age of the particles
• Render again to check! [image 7]

Friday 24th January – Intro to Rigging

Today, Sang Hun Yu introduced us to rigging in Maya – first of all, rigging an arm with FK, then a leg using IK. I had a little rigging before in 3D Max and a very simple rig in Maya last year, but I certainly need a refresher!

• First thing to bear in mind is the scale of a cene – the size will affect the lighting, so if necessary change the settings to metres
• set your project in Maya – set increnental save on – 25fps PAL
• you can set a new orthographic view if you need – panels – orthographic – new – top
• if you want to set a new shelf, click the little triangle to the top left of the screen and name it appropriately – we’ll be using the joint tool, insert joint tool, freeze transforms, delete history etc
• to change the joint size – display – animation – joint size (x-ray joints to see the bones through the model)
• when using the insert joint tool, full screen it so you can click drag the size from the original joint
• you can use the text area in the outliner or in the main tool bar to select all the bones – e.g. ‘bn*’
• click the insert key to move an isolated joint
• ctrl + shift + RMB – change the object/world orientation of the gizmo
• to select a hierarchy, e.g. the finger joints – select the parent joint – in MEL, ‘select -hi;’
• then rotate the fingers to check it works
• the thumb doesn’t work so well however, so we need to reorient the gizmos
• display – transform display – local rotation axis
• to reorient the thumb rotation – select thumb, select the top joint – F8 – also click the ‘?’ in the tool bar – click x, y or z on the joint, then rotate the gizmo into a new position where the Y axis relates to the ‘up’ direction of the new thumb rotation (if that makes sense?!)
• once they’re reoriented select the whole hierarchy (MEL: select -hi;)
• NB – if you want to create a button out of a bit of script you’re likely to repeat, do it: by finding the command in MEL; highlight and MMB drag on to your chosen shelf; edit the shelf and give it a name! 
• parent the fingers and thumb to the wrist
• select the forearm
• select the Y and Z axis for rotation in the channel box – RMB lock selected as we’re not using them
• create a controller (e.g. a circle) and snap to the shoulder joint (‘v’)
• delete the history
• freeze the transforms for the controller(s)
• select the controller first then shift select the joint – constrain – orient (options) – make sure maintain offset is checked!
• when you select the controller now, the bones should turn purple
• now do the same for the elbow and wrist joints
• parent the wrist to the elbow, parent the elbow to the arm controllers
• Tip – the little dotted square box with the arrow pointing to it above each of the viewports – this isolates the selected element
• for the forearm joint, we’re going to create an expression – select the forearm joint – open the attributes – RMB over X rotate and ‘create expression’ as seen below: [image expression]
• Tip – to change thye gizmo sizes use the + or – keys! That simple!

I didn’t realise until the afternoon session how detailed Sean’s notes would be, so rather than writing them all here again for the leg IK, I’ll simply refer myself to the notes for Arm Rigging and Leg Rigging Lessons in the Rigging Overview folder.

Reflection on Practice

This week we discussed our current research questions to analyse them further and see if we could focus more specifically on the chosen problem. So what do I mean by that? Well, could I rephrase my question from, “Can music be visualised in 3D to educate and entertain?” – because, if the answer to any research question is ‘yes’ or ‘no’, then clearly the question has to be rephrased to become something more complex that requires more than a one word answer. At this point then, my question needs work!

So, to begin, the question ‘can?’ needs to be changed to something along the lines of ‘how’ or ‘to what extent’. I need to describe the means by which I am going about the process, for example, by the use of particle dynamics. In addition, ‘to educate and entertain’ is too broad a phrase.  I had not really appreciated the need to do this until it was brought up in discussion; I had felt that after the research poster was completed, other more pressing practical concerns would be a priority. However, it would be more accurate, at this stage at least, to rephrase it to:

“How can particle dynamics be used to visualise music in 3D?”

Even though this seems an improvement on the previous version, it still needs reviewed and updated. I feel I need to mention something about Cymatics as the basis for my visualisation, but at this stage I don’t want to ‘shoehorn’ it in until an appropriate way to do so can be found. This is something that will need to be done on as regular basis as and when the research progresses.

As for the rest of the week work, I have finished the first version of the soundtrack that will be the basis for my project – I have sent it off to John Stuart Reid to be visualised in water, at my own expense, which I will use as reference for the modelling of my own interpretation.

This week’s Going Live meeting has kick started my own input – Phil has asked us to have some test assets for the first deadline with Axis – this is something I didn’t anticipate, thinking that the preproduction design would be completed before any modelling would take place. Regardless, I have designed a basic dragon’s head, based on the mood boards created by Lilly and Steph. We can use the head to try different textures and see if we can successfully do a test for the ‘paper’ or ‘parchment’ texturing that we’re looking for. Hopefully the team will like my first attempt.

Week 16 – Particle Goal Tests (and Fireworks continued), Mash Tutorials, Past Conference Paper Presentations, Going Live, Reflection on Practice

January 13th…

This week, I continued with the tutorials on creating fireworks with particles. Before that, however, I completed a test for my research using particles and 2 simple curves as a ‘goal’ for the particles. I key framed the weight slider between the 2 curves to create this simple animation:

I think this approach might work well with the core shape of the cymatic structures. Obviously, the shapes will be far more complex than this test, but a combination of particles with displacement maps and modelled curves or shapes with appropriate materials, could be a viable combination. Here are the basic steps invloved:

Maya – Controlling Particle Systems with Goals (From Create Dynamic Simulations Course)

• The tutorial starts off with a volume emitter filled with particles
• Create you goal object
• Select the particles system, shift select the object
• Particles menu – goal
• Particle Id will go to the corresponding vertex
• In particles shape tab – goal weights and objects
• Goal smoothness – value of 0, the objects will stick completely to the goal object
• A high value makes it seem as though there is a time lag for the objects following behind
• Can turn on and off using the goal active check box
• Create a second goal (same as you created the fist)
• When you go back to goal weights and objects tab there are 2 sets of attributes now
• Use the weight slider (below goal smoothness) to control how the objects go from one object to the other – animate this!

(Particle systems are the same as soft bodies so you can have a soft body mimic the shape of it’s goal)

In addition, I have been looking again at the Mash plug in, and have covered the following tutorials but will need to apply this knowledge to my research:

Mash Tutorials – Multi Curve, Distribute and Mesh Distribution Nodes

Multi-Curve Node

• Start off with an object
• Add a random node
• Up the number of objects, for example, 10
• Add a noise node
• Up the x, y and z amplitude to approx. 12
• Hide original object
• Add additional frames to the scene
• Go back to the waiter and add multi curve node
• 3 curve types – join the dots; tracer; point to point
• Join the dots – does what it says!
• You could emit particles from the curves, although they’re drawn in straight lines.
• Tracer – no of curves (depends on the no of objects you have), tracer length determines the length of the tail – NB if using paint effects, they won’t appear until the tail stops growing, so if you have a tracer length of 32, you won’t see it for 32 frames (again, you can emit particles from the tracer curves)
• Point to point – connects all points to another point (0, 0, 0 by default), but you can connect it to another object – create point – which creates a locator that you can move to suit yourself

Distribute Node

• Create network, add distribution node, back to waiter and up the number of objects (64)
• This node spreads values out (scale, rotation, etc…)
• Spiral example: arrangement type – radial; distance x – 10; distance y – 360; this is because of the bias ramp (Ramps) which by default is set to the lower left position (selected value 0). If you move the position up to the top (selected value 1), it becomes a circle.
• Mesh settings – strength – controls the overall size of the circle; random strength – changes the distribution from the centre point – could maybe animate a distributed collection of these as a cymatic shape?; step strength – changes the outer ring distribution
• Also have individual bias ramps – try using the ramp on bias ramp Y to set the default ‘selected value’ to 1 to create the spiral again from a different angle
• Also Spherical arrangement type – very cool, lots of possibilities!
• Amplitude z is the radius!
• Change the bias ramp selected value to move the objects
• If you wanted to fill the sphere – selected position 1, selected value 0
• Automatically get animation on the spherical arrangement type! Has animation speed setting
• Also have Grid arrangement type – grid settings (x, y, z)
• Graphics card affects the speed of Mash the most, then the processor
• Mash_pointsShape1 – if you disable the ‘enable points’ box, it speeds up viewport rendering/interaction
• Add in an object to be used as a Mesh ‘Goal’
  
• Smooth it a couple of times
• Select the sphere, ctrl select Mash waiter
• (Mash_Distribute_Pos tab)On the distribute node, Inputs – Connect Mash – NB – I don’t seem to have access to Inputs! (In between Falloff Object and Node Behaviour)
• There is an alternative way to connect the Mesh:

1. Select a Mesh

2. Add select the Waiter (Apple key on Mac, control key on PC)

3. Navigate to the distribute node tab

4. Roll down the Mesh settings

5. Click ‘Connect Mesh’

• Change arrangement type to Mesh Vertex (or this!)
• This will apply the objects onto the sphere’s vertices
• You can create a crude ‘goaling’ effect by changing the spherical settings – random strength value
• Also, random seed value determines how the objects are spread over the surface.

Mesh Distribution (from the Distribute node) – simple version for goals

• Create the object that will be distributed
• Create the object to distribute it on
• Create mash network with the first object selected
• Add distribute node
• Change arrangement type to mesh
• Ctrl connect the mesh then the waiter and click on the connect mesh button
• Up the amount of objects in the waiter
• By default objects get scattered, try the other options! By vertex, face, face centre etc – it organises them by number of vertex etc.
• Distance x – push the objects outward along the normal
• If you want your objects to face in the direction of the normal (or have control of the rotation in general) open the node editor
• Expand the bottom half of the mash)distribution_pos and the waiter (if you want to see the current connections)
• Connect out rotation pp of the distributionPos to (other)in rotation pp of the waiter
• You can now control it with the up vector, but it’s easier to do by rotating the original (hidden perhaps?) object! (90 degrees to the y axis?)
• Again, can choose face centre or whatever type of method you fancy

Returning to the Maya Particles Fireworks Lessons:

Lesson 11 – Adding a Trail to the Ring

• Select ring particles, go the ringShape node
• General control attributes – change conserve value to 0.98, so that the particles lose about 2% of their velocity every time a calculation of the remaining velocity happens. So effectively, they slow down!
• Need to add gravity to the falling ring particles now
• Open the dynamic relationship editor (Window – relationship editors – dynamic relationship editor)
• Expand the ring group, select ring, then select gravityField1 in the right hand window, and then close the window.

• The gravity field should now affect the ring particles, making them drift down gently
• Now, change lifespan to random range, with a random value of 0.1
• Remember that you’ll need to do a playblast to accurately judge the real speed it’s running at, with cached particles and so on!
• Now, to create the ‘pixie dust’ effect, we’re going to emit particles from the currently selected ring particles. So, select the ring particles, then emit from object (using particles, not nparticles!)
• Rename the new particle ‘ringTrail’ and the emitter ‘ringTrailEmitter’
• Parent the ringTrail particle into the ring group
• Change the ringTrailEmitter basic emission speed attr – speed to 1.2; speed random to 0.7
• Change the ringTrail particles conserve to 0.99 (general control attr)

• We want to change the emission rate of the ring particles over their lifespan so that the centre of the bursts don’t seem so empty as compared to the extruded parts where the particles are slowing down and concentrated together
• First though, we need to take these particles and connect them to a gravity field. We could do the same as before but it doesn’t look right as the conserve on the original particles is set fairly high makes it look as though the gravity is pulling them down quicker than they should be.
• We’ll connect a new field – so, select the ringTrail particles and open up the fields menu and select air – air fields are good for light objects as they have a maximum velocity which never allows objects to accelerate past
• Air field attr – magnitude to 7; attenuation to 0; make sure spread is off, so it doesn’t fan out, we want a parallel force!; turn off ‘use max distance’ as we want to affect everything everywhere!
• Need to change the direction of the y axis to -1 so it doesn’t fly upwards! (air field attr)

Lesson 12 – Tweaking the Trail Emission

• Select the ringTrail particles
• We want to adjust the lifespan – lifespan mode random range; lifespan 2; lifespan random 0.3 – might seem a little long, but we’re going to have them flicker in and out, so we’ll leave it for now
• Going to set up a per particle emission rate for these particles. To do this, remember and select the emitter – then the particles menu – then choose per point emission rates

• So the attribute should show up in the ringShape per particle array attributes – again, renaming is essential to keep track of the attributes here
• This time we’re going to create a ramp (RMB ramp) – RMB again over the expression, arraymapper1outvaluePP – edit ramp

• Delete the middle grey swatch and move the white one up to about a third of the way up so the initial ‘life’ of the particle is brighter for longer
•  Choose ‘smooth’ for the interpolation
• Problem here – no particles seem to be emitted – this is because the colour of white sets the emission rate to a value of 1, which is very low! (1% of the original emission rate!)
• To amend this, follow the output node of the ramp to take you to the array mapper attributes where the min value of 0 is black and the max value of 1 is white.
• Change the max value to 200 and try that
• If you want the early part, or birth of the particle to be a little brighter we could move the white slider down a little on the ramp and then up the max value to 250

Going to increase the speed ringTrailEmitter again to 1.7 (from 1.2)

Lesson 13 – Add Sparkle with Expressions

• Add  a colour to the ringTrail particles to see them better, so select the particle then the shape node, add a color attr from the ‘add dynamic attributes’ section – add [per object attribute as it doesn’t matter if all the particles have their own separate colour

• Scroll up to the render attributes section, there is a red, green and blue – set them to 1, 1, and 0.7 for a yellow tint

• Add attributes for current render type – this adds the color accum button so that the particles can have some kind of colour overlap to make the particles brighter in the central areas
• So, for the flickering effects, first off, PP expressions
• Add a dynamic attr for opacity – add a per particle attr this time
• Create runtime expression before dynamics from the opacity attr (Per particle attributes section)
• Type in the expression:

//give it a little time before sparkling – going to use the sine function as it cycles between 2 //extreme values(on/off) – run it off time but more quickly, hence the * 20, also a particle //offset based on the Id so every particle doesn’t go on and off at the same time

if (.age  > 0.3)

.opacityPP = sin(time * 20 * .particleId)

However, to make the sparkles less bright (they’re as bright as the original burst at the moment), multiply the RHS of the equation by something like 0.3

if (.age  > 0.3)

.opacityPP = 0.3 * sin(time * 20 * .particleId)

Now, however, we want the original burst not to be as bright, so if we select the ‘creation’ button in the expression editor and type in the following, the main burst will be a little lower/the same as the flickering maximum:

.opacityPP = 0.3;

The flicker will cycle between 0.3 and -0.3 due to the sine function – but this is absolutely fine!

NB –this looks good but the problem with this method is that, 5 times every frame, Maya has to calculate the expression for each object – runtime expressions! If there are thousands of particles then the calculations add up very quickly!

So, I will delete the creation expression and the runtime expression as we’re going to use ramps instead in the next lesson. (I’ll keep a copy of this file regardless as jjmcg_runtime_sparkle.ma)

Lesson 14 – Adding Sparkle with Ramps

This time we’re going to use the Ramps method of getting the particles in the ring trail to sparkle

• ringTrailShape – opacityPP – create ramp – edit ramp

• Delete the middle swatch – if you check it out now, you’ll see the particles fading over time
• We could add in intermediate black and white swatches to have the ramp alternate between opaque and transparent but this is a time consuming way of doing it if you want to get the accuracy spot on
• We want to look at the way we can edit it and customise it in the hypershade
• So, open the hypershade and show inputs an outputs – the texture doesn’t have anything feeding into yet, no texture information. For example, if you created a ramp in hypershade, it would have a 2d texture placement node attached to it already
• As an experiment, RMB – create – general utilities – 2D placement – default connect to the ramp (MMB – default)

• In the 2d placement attributes, up the repeat UV ‘v’ ramp (second value!) to 7. You’ll see a stripy version in the hypershade as a result
• However, we want to make it a symmetrical transition, so add a black swatch at the bottom of the ramp and move the white swatch into the middle
• We would expect this to work as an alternating white/dark flicker, but alas it doesn’t work! We only get 1 fade out. The array mapper (on the RHS of the ramp) doesn’t look beyond the ramp node to see if there’s anything controlling its placement! So, the repetitions are ignored! So, delete the 2d placement node!
• A solution – first off, delecte the top colour swatch ion the ramp, make the bottom one really bright white, and map another ramp to the middle swatch by selecting it (the circle) then clicking the black and white squared button to the right of the select color attribute slider

• Update the new ramp to be black – white – black, then select the new 2d placement node and change the number of repetitions back to 7
• So, the loop is contained within those colour calculations in the new ramp!
• Try it out – good, but all still a little bit bright
• In the expressions example in the last lesson, we added a multiplier of 0.3 to the array mapper, so we can add this back in here. RMB on opacityPP – arrayMapper2.outValuePP – edit array mapper – array mapper attributes – max vaue 0.3
• Problem – we see a ripple pattern as the particles are more or less born and die at the same time – we can up the random lifespan to 0.6 or 1 in the lifespan attr of the ringTrailShape
• Helps a little but we need to change the arrangement of the ramp
• Change the interpolation to smooth and shrink the amount of white available for the flickering (see image)

• Works much better!

Lesson 15 – Tapering the Trails

We need to make the trails less ‘finger like’ by tapering them. There’s no velocity attr that we can use in the trail emitter so we need to get the particles to figure out whether they were created more towards the centre of the burst, hence they would move faster, or further away from the burst, in which case they would move slower. So, how to do it? Well, particles that are emitted from other particles can inherit their velocity, so we’ll use that to create a custom initial velocity in a creation expression as follows (so we’ll pay attention to that velocity but we’re not going to use it!):

• Select the ringTrailEmitter
• Go to basic emission speed attr and zero out the speed and random speed attributes (don’t worry we’ll sort it out!)
• Go to the ringTrailShape tab and under emission attributes turn up the inherit factor to 1

• Doesn’t look like anything is happening yet because all the particles are inside the spheres
• We need to create an expression –ringTrailShape, per particles attr – RMB over velocity – creation expression
• We’re going to capture the velocity of the parent particle then convert that into a scalar value (which is the speed) – ‘sphrand’ function will return a vector within a spherical shape within a value of 1, while the unit function makes sure the returned value remains a value of 1:

vector $vel = .velocity;

float $speed = mag($vel/10);

vector $dir = unit(sprand(1));

$vel = $dir * $speed

.velocity = <<$vel.x, $vel.y, $vel.z>>;

//so finally we set the velocity to be equal to the direction times the speed

//we’re keeping the speed of the original velocity of the parent particle but we’re generating our //own direction for it. So we take it back and plug them into the particle

Lesson 16 – Setting Up the Spiral Fireworks

First thing to do here is to change the big spheres to point:

• ringShape render attr – particle render type – points
• add attributes for current render type – check color accumulation as well
• add dynamic attributes – color button – add per object attribute – then set color red/green/blue to 1 each

• So far so good. Now, however, we’re going to turn off the main ring shells (that in turn spark off everything else), so we can focus on the spiral fireworks – so, I ringShellShape, turn off the ‘is dynamic’ button in ‘general control attributes’
• Create a new emitter, rename it ‘spiralShellEmitter’
• Rename the particle ‘spiralShell’
• Group them and rename ‘spiralGroup’
• We’re going to use the same settings as we used for the shell emitter, so change the emitter to a volume emitter – distance/direction attr, set Y to 1 so they go up – random speed of 5.0 –volume speed attributes, away from centre 0, along axis 30, random direction 5.00
• Transform attr – sacle – Z axis set to 40.00
• You can position it on top of the other one if you want
• Set basic emitter rate to 5
• Spiral shell particle – conserve to be 1; lifespan to be lifespanPP only; render type streak; line width 3; tail fade 0.5; tail size 2(add attr for current render type)
• Add gravity as before (see image)

• Next thing we want to do is put the same mind of detonation on the spiral shell as we did on the ring shell. Open up the after dynamics expression from the ring shell, copy and paste it into the spiral shell expression for lifespanPP
• It’ll be almost the same apart from needing to change it from ringShellpartcle to spiralShell particle – so change the instances! (see image for the script details)

• So at this stage, they’re dying out rather than getting pulled back to earth through gravity
• So again, select the spiral particles – particles – emit from object – rename to ‘spiralBurstEmitter’ – rename the new particle to ‘spiralBurst’
• Parent under the spiral group
• Select the emitter – particles – per point emission rates (so it’s added to the spiralShellShape’s pp array’s attributes
• Now un-comment the line that refers to the emitter rate of 30000 in the after dynamics expression
• Change spiral burst emitter speed to 20 and random to 5 (basic emission speed attr)
• So we’ve set up the basic detonation, we’ll tweak it next

Wednesday 15^th January – Reflection on Practice Past Conference Paper Presentations

Today we had presentations from five academics, on a variety of subjects, detailed below. The idea was to let us, the students, see the kind of qualitative and quantitative information that can be transmitted within a 15 minute slot. The structure and the approaches each person had were different enough to give us a good grounding in the approaches we might like to use ourselves when it comes to taking part in a symposium later in the year, delivering information on our own research.

1. Calum Colvin – Programme Director Art and Media. Calum had a relaxed and comfortable approach to talking to the audience, with a good sense of humour to make the audience feel comfortable. He delivered: a historical background firstly; used a number of slides and 3D glasses to appreciate the nature of the 3D art; delivered a critical review of his contemporaries; he described his workflow and compared his influences. Here are some of the pointers in bullet points that I picked up from his talk:

• Don’t apologise for what you do!
• Either look at the audience for the whole presentation or not – i.e. if you’re going to use cue cards, you need to be mindful of how you use them!
• Humour is good, be yourself as much as you can!
• He used a laser pointer to effect
• His pacing was even, not rushed
• He delivered the ideas in the first person – “I did this…I did that…”

2. Hazel White – Course Director Master of Design for Services. Hazel introduced her work with children’s hospices and the nature of the objects that were designed to help kids and their families.

• Hazel had some of her questions on her slides – less eye contact with the audience, but she did mention the rote repetition type of methods that she used in order to feel more confident with talking to groups of people
• She used ‘diversion tactics’ to get information from her clients – i.e., some of the workshops that were set up, were very useful ways to make people feel comfortable and talk in a more informal and open manner about their kids etc and what they did or what their routines were – this was better than a formal interview!
• She used a remote control slide changer and had no notes
• If you aer going to keep notes, she says, keep them on a ring
• If you’re going to drink, use a mug rather than a bottle! Better for the appearances of nerves!

3. Elaine Shemilt – Chair of Fine Art Printmaking. Elaine talked about the links between science and art, beginning with shipbuilding, Antarctic discovery and other extremely worthwhile expeditions.

• Elaine’s approach was a little more scripted – she read off of the screen quite a bit, but still very interesting!
• Explained how drawings led others and herself to do this or that in a scientific manner
• Described her personal background and how that led her to St Georgia and the research there in saving the albatross and other work
• One very interesting point she made was that scientists asked artists to scientific breakthroughs across to the public, via the use of colour and imagination. I could see the potential parallels to that and my own research and it I found it quite hopeful!

4. John Anderson – Senior Research Assistant, 3D Visualisation Research Lab. John’s work was in linguistics and natural language processing.

• He introduced the concepts and a few terms and definitions to put us in the picture
• The grey monotone slide design I felt was a little dull
• On the other hand, other slides provided too much information through graphs etc
• He stated one problem, then broke it down, and then did the same with others
• Used diagrams to illustrate points including early tests and problems
• Mentioned the benefits of rapid prototyping

5. Sarah Cook – Curator, Reader and Dundee Fellow. Sarah talked about her role as a curator, working within different spaces and with different artists.

• ‘Misfits’ – time based art?
• She uses keywords as a starting point for her own style of delivery
• Sarah has a more free flowing improvisational style
• She uses a number of graphics to scroll through, stopping at 1 or 2 – this gives the audience a kind of ‘shared’ experience and also adds to a relaxed atmosphere
• She asked simple questions and encouraged debate on the questions
• Technological shift or philosophical shift?
• Add captions to photos and video if it’s possible!

Thursday 16^th January

So, today the brief for Going Live was unveiled and the Hobbit is the theme of a promo film that we have to deliver. It has to be a film within a film kind of piece, where the style of the animation does not necessarily have to match what the Hobbit was like. This is a relief! The style should be original but match the values of the film.

After a couple of discussions, we seem to be heading for a back story on how Smaug came to be. The style will be based on the parchment map, seen in all of the films, with a potential pop up style of 2D meets 3D animation. Myself, and the rest of the class, have volunteered for a number of roles apiece, so we will see what the new week will bring and Phil has to add to the suggested roles. The list of confirmed roles will be seen here next week!

Reflection on Practice

Overall, the afternoon was a valuable experience, also knowing that this is where we’ll be presenting our research it gives me an idea of what to expect. As far as the rest of the week went, I’m now excited about my forthcoming research, following the simple but effective test with particles earlier in the week. I have been trying a variety of different ideas to see what would be a potential route to go down, none with the same amount of assuredness that the particle test has had. So, I’m more hopeful now that this line of research will provide the desired results. I’ll see how that develops!

In addition, we have been given the brief for the ‘Going Live’ module, which in the most general terms, is a promo film for The Hobbit. This both excites and slightly disappoints me somewhat. I’m mildly disappointed that for a VFX company who delivers such innovative ideas, they would choose a subject matter that has been covered in such breadth and depth already as the Lord of the Rings/Hobbit universe. I would have preferred something a little more ‘undiscovered’! However, it clearly depends on how we can come up with something innovative within that universe, and at the same time, how we go about creating this piece is a challenge, as is working with the rest of the team in a number of roles. On top of that, we could well have been working on some soulless advert, so in that respect, I am truly grateful!

Semester 2 – Week 15 – More Particles (Fireworks Tutorials), Intro to Reflection on Practice

Semester 2 – January 2014

To continue with my research into using different techniques for modelling sound, I decided to look at a series of digital tutors lessons on how to create fireworks. The thinking behind it focusses on the idea that the cymatic bubbles of sonic energy, could burst outward in a spherical manner via the use of particles. So, whether only part of the course is relevant remains to be seen, but if any part of this is useful then it will be worthwhile.

So, after the usual lesson 1 introduction, here are a series of shorthand notes:

Advanced Particles to Create Fireworks 

Lesson 2 – Setting up the Ring Fireworks

• Use a dark backdrop in Maya so you can see the particles
• Change the playback rate to ~0.2
• Change the simulation rate – solvers menu – edit oversampling or cache settings – oversampling – 5 (this is the reciprocal of 0.2) [This number has to be divisible by 250! – 250 jiffy’s in a frame!]
• Create emitter – volume
• Scale it along the z axis to stretch it out along the screen
• Change the rate to 2/sec
• Volume speed – away from centre – 0; along axis – 30

To make the particles bigger, select them, (particleShape1) –

• render attributes – particle render type – change to streaks
• add attributes for current render type – line width 3; tail size 2; tail fade 0.5;

To randomise the direction:

• volume speed attributes – random direction – 5.00
• basic emission speed attr – speed random – 5.00

Lesson 3 – Killing off the Ring Shells

Housekeeping and Using per particle expressions.

Rename the elements appropriately now – the particles themselves should be renamed RingShell (as in the fired shell before it explodes) whole the emitter is the RingShellEmitter. This will cause less hassle later on!

• Lifespan attr – should it be constant or random? Prefer to use PP only!
• RingShellShape tab – PP array attr – runtime after dynamics (although it doesn’t matter which one you select initially as you can select the radio button once the expression editor is opened)
• // this is a comment line in MEL

//capture velocity – you can just put a dot before the attribute a Maya will know which object you //refer to as long as you have the right one selected before opening the editor!

Vector $vel = .velocity;

//trigger detonation if shell slowed enough on the y axis

If ($vel.y < 3)

{

//detonation kills the original particle: set the life to 0

.lifespanPP = 0;

}

• Click create – check the helpline to make sure it didn’t go red so it works!
• Check it out when you play! The particles should die after they slow down on their ascent.

Lesson 4 – Emitting the Burst

Now we need to create a burst from the individual particles themselves. Effectively, creating an emitter from a particle:

• Select RingShell – emit from object
• New Particle1 – rename to RingBurst
• Rename the emitter to RingBurstEmitter
• NB – it’s important to rename these as you go!

If you want to control when to emit particles:

• select the emitter – particles menu – per point emission rates
• then, choose the particle, particleShape attr – it will have added the newly named emitter to the attributes in the PPattributes menu.
• For example, here in lesson 4, ‘RingBurstEmitter Rate PP’

Now, to add to the previous MEL script:

//Detonation sends out coloured burst particles

RingShelShape.RingBurstEmitterRatePP =1000;

Because the lifespan is set to 0 already, this will just give a single burst of the emitter before returning to 0!

This could be very useful for my Cymatic images – it’s an alternative to keying the individual frames – I will need to test it out and see!

Lesson 5 – Bust Emission and Behaviour

• Open the expression editor – by whatever means!
• Select filter – by expression name (will list all the expressions that exist in your scene)
• ‘runtime after dynamics’ – Maya first checks the emitter rate (e.g. 1000) – then it checks lifespan (0!) – so, it will give a frame of burst particles before killing them off!

First thing here is to change the emitter rate to a higher number, e.g. 30000, for a bigger burst!

‘Conserve’ of particles – how much they slow down – this is a very sensitive value, so you won’t have to change it too much! – try 0.95 (RingBurstShape attr).

To add gravity to particles:

• Select the particles (RingBurst here)
• Shift select the GravityField1
• Go to the fields menu – ‘affect selected objects’

Change particle lifespan:

• Lifespan 1.5
• Random 0.2

Render attributes – change to ‘Streak’

• Add attributes:
• Tail size – 5.00
• Tick the color accum checkbox so that the layered streaks amplify the colour
• Tail fade – 0.5

Lesson 6 – Colouring the Bursts

Remember that all of the particle bursts here are part of the same particle system. So, we’re going to colour them based on their particle Id number. We’ll use an expression based on when the particles are born. So, some are even numbered and some are odd. To keep it simple, we’ll just use 2 colours – e.g. odd – red; even – purple.

• So, add dynamic attributes (RingBurstShape)
• Color – add per particle atttr – add
• General – add parentId (particle tab)

You might need to change to wireframe mode as the RGBPP attr turns them black!

• Select some of the particles – RMB and select ‘particle’ first (component mode) – look at its properties by opening up the component editor (general editors menu) – go to the particles tab

• Each cluster has its own Id number
• To keep it simple – 2 colours for now! So, even or odd!

Modulus Operator

As in other programming languages, this operator works out what the remainder of a division of 2 numbers is:

• It’s represented by the ‘%’ symbol
• For example, in MEL:

For ($i = ; $i < 40; $i++)

Print (($i % 2) + “ “);

The result here will give you a series of 1 and 0 repeated. If you change the division umber it will affect the pattern of results.

So, a modulus of 3 will give 1, 2, 0, 1, 2, 0, etc…

Modulus of 5 will give 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, etc…

This is a good operator for setting up an expression where you want a pattern to repeat as something changes.

• So, RMB RGB PP – creation expression this time
• The script is as follows:

Float $hue;

If (.parentId % 2 == 0)

$hue = rand(0, 0.05);

Else

$hue = rand(0.7, 0.8);

.rbgPP = hsv_to_rgb(<<$hue, rand(0.7, 1), rand(0.7, 1)>>);

See the image below for comments:

• Create the script and execute
• Remember and return to object mode and shaded view to check it!

Lesson 7 – Emitting Particles for the Ring

Open the expression editor.

• We’re going to insert an empty particle object
• In MEL command line, type in ‘particle’ and press enter
• It should now appear in the outliner – rename it ‘ring’ and parent it to the ring group
• Change from points to spheres (render attr)

In the expression (for RingShellShape) add:

//emit ring particles

emit –pos 0 0 0 –o ring;

Where the position value is a float, while the object emitted is called ‘ring’. We’ll add to this! When you run it, you should see a sphere (or several) sitting at the origin. We haven’t told them to go anywhere yet. You can check this by opening the component editor!

//capture detonation position

vector $pos = ringShellShape.position;

Then update the previous line to:

Emit –pos($pos.x) ($pos.y) ($pos.z) –o ring;

If you need help on commands, type into the MEL script editor ‘help emit’, or whatever the command is. Press enter and it will give you a synopsis of the command. For example, Flags (variable types):

‘-at’ – attribute – multi use (string)

‘-vv’ – vector value – multi use (float, float, float)

So, rewrite this line of script, using random values for the direction vector here:

Emit –pos………($pos.z) –at “velocity” –vv 10 20 5 –o ring;

So, we’ve created our own flag and assigned a random value to it. Execute and see!

The new spheres all fly off with the scripted direction.

Lesson 8 – Creating the Ring Pattern

‘rot’ function example:

For ($i = 0; $i < 12; $i++)

{

Vector $p = rot(<<5, 0, 0>>, <<0, 1, 0>>, (6.28/12*$i));

Emit –pos ($p.x) ($p.y) ($p.z) –o demo;

}

When you run this, you get a ring of 12 particles, the 1^st about 5 units out on the x axis, while the others are rotated around the y axis central position.

The rot function takes 2 vectors and a scalar value and outputs another vector. So, we have the initial position of 5,0,0 in space and the second vector as the axis in space and finally the scalar value which rotates it around the 2^nd vector, which is the float value determined by the last part of the line above.

Remember when Maya is working out the degrees to which something needs to be rotated, it’s measured in radians, not degrees! There are  radians in half a circle (3.14) so there is 6.28 in a full circle. So, we have 12 steps in the first line of the ‘for’ loop, and the amount is divided by 12 as well to make it accurate. If you only looped for 6 steps, you would get half a circle of points!

So, to update the expression again:

//emit ring particles

for ($i = 0; $i < 12; $i++)

{

vector $vel = rot(<<5, 0, 0>>, <<0, 1, 0>>, (6.28/12*$i));

emit -pos ($pos.x) ($pos.y) ($pos.z) -at “velocity” -vv ($vel.x) ($vel.y) ($vel.z) -o ring;

}

When you run it, you’ll get 12 spheres emitting out from the central point of each burst. Next, we’ll have to customise this to make it look more realistic.

Lesson 9 – Understanding the Cross Product

The spheres are all flat as they are revolved around the y axis. What happens if we change that?

If we change the middle value from above (vector $vel = rot(<<5, 0, 0>>, <<0, 1, 0>>, (6.28/12*$i));) to something like 0, 0, 1 the spheres will rotate on the z axis, or if we do 0, 1, 1 they’ll rotate on a diagonal type axis.

Cross Product – the cross product of 2 vectors can be represented by the right hand rule (see Wikipedia) whereby the resulting vector is at 90 degrees to both the originating vectors. So, your index finger is A, middle finger is B and your thumb is the cross product.

So, whenever we update the 2 vectors we need to describe the position of the burst, the cross product will act as the basis for the axis to base our rotation function on. The length of the vectors also has an effect on the cross product, but we’re not concerned with that in this example.

So, we can use the velocity vector as the main value along with any other vector to work out the plane on which the emitted particles will go in a circle, perpendicular to the velocity.

Lesson 10 – Finalising the Ring Pattern

Before ‘//emit ring particles…add in:

//Capture detonation velocity

vector $shellVel = .velocity;

Then change:

// Emit ring particles.

for ($i = 0; $i < $num; $i++)

{

vector $vel = rot($start, $shellVel, (6.28/$num*$i));

emit -pos ($pos.x) ($pos.y) ($pos.z) -at “velocity” -vv ($vel.x) ($vel.y) ($vel.z) -o ring;

}

So, this works out the right angle for the rings, but now we need to add in some random variations for them in terms of speed, number and so on.

The ‘unit’ function will remove any random factors by making everything a value of 1. This initially will slow down the velocity of the bursts, but we can then scale that up and have control of how fast we want that to be.

So, the expression looks like this now:

vector $start = unit(cross($shellVel, <<0, 1, 0>>));

Now, add a random function to speed it up to between 30 and 40. It’s a bit fast but we’ll sort this out later:

vector $start = rand (30, 40) * unit(cross($shellVel, <<0, 1, 0>>));

Now, we’ll add in some randomness to the velocity and direction so that the rings won’t be perfectly flat etc:

$vel += <<(rand(-2, 2)),(rand(-2, 2)), (rand(-2, 2))>>;

Finally, for now, randomise the number of particles per burst (rather than 12 for each), put this in before the emit ring particles section:

//Randomise number of emitted ring particles

Int $num = rand(10, 15);

Them replace the value of 12 with $num in the 2 places below it. See the image below for the final code thus far for lesson 11:

Wednesday 8th January – Relection on Practice Introduction

This week we were introduced to Sharon Campbell and the Reflection on Practice module.

What is reflective practice? This was the first of many questions designed to get us thinking about what we have been doing, and recognising some of the things that we do and dismiss, that may be valuable in our course of study. Personal ideas can be a valuable asset to the process. My initial answer to the first question was something like:

‘The planning and trials of new ideas, experimentation, or the planning of a process followed by critical analysis of the results and the steps involved, noting any potential changes etc.’ 

We also had to imagine a reflective dialogue with anyone who might be useful in connection to our research. I chose to speak with (as myself) John Stuart Reid, the inventor of the Cymascope. As it happens, I have begun a real dialog with him via email, the details of which I will note in forthcoming blog entries.

In addition, this week we have been handed our first assignment from Jeanette, focussing on the idea of creating a focus group to gather information for our research. Some projects may well be more beneficial than others for this type of information gathering, but the process itself will be valuable nonetheless. As yet, I don’t know whether a focus group will be a significant attribute to my data collection, but we will see how it progesses.

Reflection on Practice

So, although the first week of the second semester has been sparse in terms of taught classes, there have been a few sleepness nights as I have been going through the seemingly endless list of things to do over the coming months. More specifically, one of the first things I need to finish off, is the soundtrack for the research film. Typically, this would be done near the end of production, but as it is the basis for my own research in many ways, I have 2 weeks to record and master a 2 minute piece of music. I plan to get the cymascope team to visualise my music in water (in 2D), and use this as a reference for my own 3D images. It will take them around 4-6 weeks to do it, therefore, time is is of the essence.

Aside from that, the focus this week is: whether the amount of time I’m spending on the digital tutors lesssons, for the fireworks, will be worth all of the effort? The idea is that I can model the cymatic shapes as curves (or some of them anyway) and emit particles from them somewhat akin to fireworks to give the idea of explosive musical energy. Clearly, not all of the lessons will be entirely relevant, but I don’t want to skip any of them for fear of missing something important. Besides, I’m enjoying it in a kind of stressful way!

Essentially then, the thoughts of the week are on balancing my time wisely, or studying things that may not be as relevant as others. I am very aware of the fact that I need to begin storyboarding as soon as possible to flesh out my film ideas and judge what shots are going to be feasible, what venues and backdrops will be suitable, and whom I need to contact if I intend to use a particular venue for shooting video as a backdrop.