TUTORIAL 7: Molecular Challenges

Transcription

1 TUTORIAL 7: Molecular Challenges Importing & animating a receptor 1) Importing molecular data into Maya 2) Using constraints and dynamic motion paths to animate the binding event Membrane with scattered proteins 1) Creating a softbody membrane 2) Using constraints to attach molecules to the dynamic membrane surface 3) Using MEL to scatter proteins automatically Extracellular Matrix 1) Using particles and MEL to create a dense mesh for the ECM 1

2 Importing Molecular Data into Maya Several PDB viewers, including Chimera and Pymol, are able to export molecular surfaces as VRML files. VRML files can then be converted to a file type that can be imported directly into the 3D application of your choice. By default, Maya is able to import.obj,.ma and.mel files. Plugins can be installed to import a number of other 3d file types, but as of yet there is no direct way to import VRML files into Maya. First, we ll explore the functionality of Chimera and export VRML files of the reovirus attachment protein sigma1, then we ll use the multiscale model option in Chimera to export the reovirus core as VRML. Using Chimera to Export Surfaces & Ribbons as VRML Open the file transferrin.pdb with Chimera. This file was downloaded from the RCSB Protein Data Bank website ( PDB ID# 1SUV). Chimera can be downloaded for free from the UCSF Chimera website ( By default, the molecule is seen as a wire model. You can tumble the model using the left mouse button. The right mouse button allows use to zoom in, and the middle mouse button pans. Play around a little with different atomic representations. Go to: Actions > Atoms/Bonds > sphere. You can also view the model as ball and stick and sphere representations. To view the model as a ribbon, go to Actions > Ribbon > show. The ribbon model is now overlayed over the wire model (or whatever atomic representation you were last trying out). To hide the atomic model, go to Actions > Atoms/Bonds > hide. By default, the ribbon appears flat. You can change the look of the ribbon by going to Actions > ribbon > rounded (or edged). Note that it is very difficult to change how the ribbon looks after it's exported! Note that this structure contains a homodimer of the transferrin receptor, with each monomer bound to two transferrin receptors each. This can be more easily seen by coloring the different proteins different colors by selecting each chain (Select > Chain) and then changing the colors (Actions > Color). You can also select chains by pressing the Ctrl key and mousing-over a small portion of the protein, then pressing the up arrow (usually twice) to select the entire chain. The default: wire model of transferrin receptor. Ribbon model with chains colored differently and with iron atoms visible as red spheres. 2

3 It would be cool to see where the iron atoms are within the ferritin structure. To un-hide the iron atoms (but not the protein) select the iron atoms by going to: Select > Chemistry > Element > Other > Fe-Hg > Fe, then unhide by going to: Actions > Atoms/Bonds > Show. We can change the color of the spheres by going to Actions > Color and selecting a color, such as red. To view the solvent-exposed surface of just the transferrin receptors, select chain A and go to Actions > Surface > show. Repeat for chain B. You can see the ribbon underneath if you change the transparency of the surface (Actions > Surface > transparency). While it is possible to export this model as a VRML with both ribbons and the surface, the file will be very large due to the high resolution of the surface. Instead, we can use multiscale models to create a smoother, less polygonally heavy surface for our receptor complex. Surface/ribbon model of the transferrin receptor. Using Chimera to Export Multi-Scale Models as VRML The multi-scale model option in Chimera is useful for creating low-polygon versions of molecules. This is especially useful for models with many subunits, such as protein complexes and polymers, or for proteins where atomic resolution is not possible or desireable. First, make sure to hide the solvent-exposed surface. By default, creating a multiscale model surface will hide the ribbons and the iron atoms, but the solvent exposed surface will not be hidden. Open the multiscale model window by going to Tools > Higher-Order Structure > Multiscale Models. A new window will appear. At the top of the window, under 'Select chains' press on the 'All' button. This ensures that your multiscale model will use all of the polypeptides. An important option to note is the 'Resolution' button in the middle section of the window. This determines how smooth or bumpy your model will be. Higher numbers result in smoother models with less molecular detail, but correspondingly smaller polygon counts. The Multiscale Models window 3

4 Press on the 'Make models' button. You should see that, at resolution 8, the model is quite smooth. Now go back to the Multiscale Model window and play around with the resolution level. Make sure all of the chains are selected, then change the resolution to 2 or 3, and the press 'Resurface.' Try higher numbers as well. Go back to a medium resolution, around 4. For our hero complex, we'd like to export the ribbon structures of the receptor proteins and the iron atoms. Select Chains A & B (receptors) and go to Actions > ribbon > show. Select the iron atoms as before, and go to Actions > Atoms/Bonds > Show. Although you cannot see the ribbons or atoms underneath the multiscale model surface, rest assured that they are there! The transferrin receptor at resolution 8 (left) and at resolution 4 (right). Export the model by selecting File > Export Scene and select VRML from the pull-down File Type menu. Make sure you save your VRML file to someplace where you can find it later, and name it something like transferrin_ribbonsurface.vrml. Converting VRML to a Maya-Compatible File Format Method 1: Cinema4D Method 2: Deep Exploration Deep Exploration (Right Hemisphere) is an application specializing in 3D file format conversion, and can both import and export a wide variety of 3d formats. Open the virus multiscale model vrml file with Deep Exploration. Export the model using File > Save As... and select either as Maya Ascii (.ma) or Maya Binary (.mb). Models can also be imported as.obj as well. Save any other VRML files that you have remaining as Maya files at this point. Opening the transferrin file in Deep Exploration Method 3: wrl2ma There are several ways to convert VRML files to something that Maya can read. Maya comes installed with a command-line executable, called 4

5 wrl2ma that can do create Maya.ma files from.wrl or.vrml files. Note that this is not a very efficient program, so it is not recommended to use this for large files (like the reovirus multiscale model) unless you're desperate. Make sure you know the file path for your VRML file. To make this easier on yourself, place the sigma monomer and trimer VRML files into the C:\ directory. wrl2ma in the 'run' window. Open the 'Run' window (Start menu > Run...). Alternatively, you can open the Windows terminal (Start menu > All Programs > Accessories > Command prompt). If you are using the windows terminal, you can find more information on wrl2ma by simply typing 'wrl2ma' at the prompt. Enter the following, replacing 'filename' with the name of your file: information on wrl2ma command in windows terminal. wrl2ma -i C:\filename.vrml -o C:\filename.ma You should see a new Maya file appear in your C:\ directory. Viewing and Optimizing Molecular Models in Maya Opening converted VRML files for the first time When you first open a molecular model in Maya, it is inevitably (1) very big and (2) very far from where your default camera is looking. So don't be alarmed it you don't see anything after opening a file! In addition, the model may be imported in lots of little pieces. Open the transferrin receptor ribbon/multiscale model in Maya (this may take a while!) You probably won't see anything in the viewport once Maya has completed importing, but if you look in the outliner, you will see that you have thousands of objects. Shift-select all of the objects in the outliner and frame them by going to Window > Frame Selection in All Views. Alternatively, simply press 'f' when your mouse is over the Perspective view. To be able to view the ribbons underneath the surface, turn on X- ray view (Shading > X-ray in the viewport menu). The imported transferrin receptor complex. Note the outliner to the left, with thousands of objects. 5

6 Select all of the Object shapes in the outliner (blue squares) and group them by going to Edit > Group or press ctrl+g. Rename the group something meaningful, like 'TfR_ribbonGroup.' by double clicking on the group name in the Outliner. Select each of the small transferrins in the viewport and name them "Tf1" through "Tf4" in the outliner. Select each of the transferring receptors and rename them "TfR1" and "TfR2." If you imported the iron as atoms, you should see four spheres in the outliner. Rename these "iron1" through "iron4." The rest of the objects in the TfR_ribbonGroup should be the ribbons. Select all and rename to "TfR ribbons." Renaming the different surfaces for organization. Scale the TfR_ribbonGroup down to 0.1 in X, Y and Z in the channel box. Keep in mind how much you're scaling since you should try to stay consistent with all of the structures you import! When you're zooming in to see the scaled complex, if your perspective camera starts acting funny, you can reset it by going to View > Predefined Bookmarks > Perspective in the Camera view panel. This resets the camera to its default settings. The pivot of the transferrin complex is at the origin, though the complex is not. Fix this by centering the pivot. Select the transferrin_group, if it isn't already selected, and switch to the 'move tool' by pressing 'w' or selecting the move icon in the Tool menu. Notice that the pivot point of the transferrin group is not centered in the protein complex. Press 'e' to switch to the rotate tool, and try rotating the complex. To move the pivot point to the center of the group, go to Modify > Center Pivot. Now try rotating and scaling the transferrin group. With the pivot centered, move the group to the grid origin using "snap to grid" (pressing on 'x' before and during moving). Now move the pivot point of the complex lower in the y-direction. You can do this by pressing on 'insert' -- the manipulator should appear as a square with a circular object in its center. Move the manipulator down to where you imagine the membrane might sit, and press 'insert' again to return to normal mode. Move the group to the origin again using the snap to grid tool. Rotate the complex such that the complex is straight. You can do this easily by switching Moving the TfR group to the origin and moving the pivot point down (to where the membrane might sit). Note that the manipulator looks different when moving pivots. 6

7 between the front and side orthographic cameras. Now that the complex is pefectly aligned and centered, we want to zero-out all of the transformation and rotation information. To do this, make sure the TfR group is selected, and go to: Modify > Freeze Transformations. Note that in the channel box, all of the attributes have been set to zero. In the TfR_ribbonGroup in the outliner, select the Tfs, TfRs, irons and the TfR_ribbon group and select Modify>Center Pivot and then Modify > Freeze Transformations. Rotating the complex in the front orthographic view to make sure everything is straight. Animating binding events using constraints An introduction to constraints Next, we're going to create a simple animation of the transferrins to move from some point in space to its binding spot on the TfR dimer. To do this, we'll be using locators and constraints. Locators are markers with transformation, rotation and scale attributes but without geometry. We will be using locators to control the starting and ending points of one of the transferrins. Before we start animating, there is one more grouping step to do -- to make the iron atoms children of the Tfs. This will ensure that the irons will move together with the transferrin to which it's bound. To do this, click on the iron atom in the outliner, and middle-mouse drag it to its corresponding transferrin. In the outliner, make the iron atoms children of the transferrins to which they are bound using middlemouse drag. Now create a locator (Create > Locator). It should appear as a green, cross shape at the origin. Name it "Tf1Loc_start" in the outliner, and move it up and away from the origin. Also, rotate it around. Create a 2nd locator and name it "Tf1Loc_end". We want this locator to sit in the exact location as the Tf1 molecule's pivot point. To do this, we will make a temporary constraint, which we will delete afterwards. Select Tf1, then shift-select Tf1Loc_end in the outliner. In the animation menu, select Move the locator away from the origin and rotate it. 7

8 Constrain > Point. The locator should immediately jump to the pivot point of the transferrin molecule (visible if you're in X-ray mode). In the outliner, you should see that a new point Constraint has been created in the hierarchy of the Tf1Loc_start locator. If you move the Tf1 molecule, you'll see that the locator moves along with it. Undo any moves to the molecule, and select the point Constraint in the outliner and delete it. We only used the constraint as a shortcut to get the locator in the correct position. Creating a point constraint. Notice that the locator is at the pivot point of the Tf protein, and that a new pointconstraint has been made. Next, we will constrain our transferrin molecule to both of the locators. What this will do is allow us to smoothly animate the transferrin's movement. Select 'Tf1Loc_start', then shift-select 'Tf1Loc_end' and 'Tf1' then go to Constraint > Point in the animation menu. You should notice that the Tf1 molecule has moved between the two locators and that a point Constraint node has been created under the Tf1 node in the outliner. Select the newly created point Constraint in the outliner (you may need to expand the Tf1 hierarchy to see it) and take a look at the attributes of the point Constraint in the channel box. You should find that there is an attribute called 'Tf1 Loc_start W0' and 'Tf1 Loc_end W1'. These determine how much the target object (Tf1) is constrained by each of the locators (start vs end). By default, the weights are set to 1 for both, which is why Tf1 is centered between the two locators. Change the values of the start weight to 1 and end weight to 0 and you should see the molecule move to the start locator. Creating a two-way point constraint. The Tf1 molecule is hovering between the two locators. Changing the weights of the pointconstraint moves the constrained object to one locator. By keying the weight values, we can create an animation of Tf1 moving between the two locators. First, make sure that you are on frame 1 in the time slider, and end time of the timeline range to 100. Set the point constraint start weight to 1 and end weight to 0 and key both by right clicking on the attribute name (Tf1 Loc_start W0, Tf1 Loc_end W1) and selecting 'key selected.' Next, move to frame 100 and change the values such that the point constraint's start weight is 0 and the end weight is 1, and key both values. Keying the start and end weights to create the animation. 8

9 When you scroll through the timeline, you should see the animation working. You may have noticed that Tf1 is not rotating at all during the animation. We can create a second type of constraint, called an orient constraint, to control the rotation of a target object. This works in exactly the same way as a point constraint. Select the start locator, end locator and Tf1, and select Constraint > Orient. Select the newly created orient constraint in the outliner, and change and key the values just as we just did for the point constraint. If you would like to have a more exaggerated rotation, simply select the start locator and increase its rotation values Notice the point and orient constraints in the outliner (left) and the controls in the channel box (right). Dynamic motion paths Just using point/orient constraints for the binding event gives a sort of mechanical look to the animation. To make things a bit more dynamic looking, we'll use a softbody curve along which a transferrin molecule will move. First, create an end locator for the 2nd transferrin molecule, and move it to the pivot point of Tf2 using the same temporary point constraint trick we used before. Name it "Tf2Loc_end." Switch the front orthographic camera (panels > orthographic > front in the main viewport) and draw a CV curve starting far away from Tf2 and ending on the locator. To draw a CV curve, go to Create > CV curve tool. To make sure that the curve ends right on the locator, depress the 'v' button for the last point and click close to the locator. This turns on the snap-to-vertex tool. Try to make the curve have at least 7 or 8 CVs for this example. Drawing a CV curve that starts distal from the Tf2 binding site and ends directly on the Tf2 end locator. Now switch to perspective view and move the points of the CV curve around so that the path is 3 dimensional. To do this, right click on the curve and select 'control vertex' in the popup menu. Press F8 to exit component mode to return to object mode. We can have the transferrin use this curve as a path by first selecting the transferrin, shiftselecting the curve, and going to: Animate > Motion Paths > Connect to Motion Path in the animation menu. If you scroll through the time slider, you should see the transferring moving The transferrin is moving along the motion path. 9

10 along the path. In addition, you should have two numbers appear along the motion path indicating the start and end frames of the motion. To get the movement to look more interesting and dynamic, we can make the curve a softbody. Select the curve, and under the dynamics menu, select Soft/Rigid Bodies > Create Soft Body and open the options box. Make sure "Duplicate, make original soft" is selected and that 'Hide non-soft object' and 'make non-soft a goal' are checked off. The Weight should be 0.5 by default. Setting the softbody options for the motion path curve. After you press 'create,' you should notice that particles have been created. If you press play, nothing has changed since there are no fields that are affecting the particles. With the curve particles selected, create a turbulence field (Fields > Turbulence). In the channel box, change the attenuation of the field to 0 and the Magnitude to something large, like 300. You should see that the curve is quite dynamic -- change the magnitude to get to a level of movement that you like. One problem with the current path is that it no longer ends on the locator. To fix this, we can change the goal weights of the particles controlling the softbody curve. By tweaking the per-particle goal attributes, we can have the last particle be fixed close to the locator while the rest of the particles are free to move around dynamically. Since the per-particle goal weights will be multiplied by the overall goal weight of the particle, the particle goal weight should be changed to 1. Find "GoalWeight[0]" in the channel box and change it to 1. The path no longer ends right on the locator when the curve is made into a softbody. Changing the collective goal weight of the softbody particles. Under the outliner, select the particles in the curve hierarchy and press F8 twice in the viewport to activate component mode. You should notice that the box surrounding the particle group is turned off and the particles turn light blue. Make a selection box around all of the particles. Open the component editor to edit the individual (per particle) goal weights (Window > General Editors > Component Editor). Click over to the "particles" tab (should be the last one). You should see a listing of particles (named pt[0] - Selecting individual particles in the softbody curve. 10

11 pt[n]) and their attributes. Change the goalpp to 0.5 for all of the particles except the last one (which should be the one closest to the end locator). Now if you play the animation, the end of the curve should stay glued to the locator position. Note that when the Tf molecule is still free to rotate and shift once it reaches the end of the motion path. To have it stop moving/rotating once it reaches the receptor, you should have the Tf molecule point- and orient- constrained to the locator as we did in the previous section. Opening the component editor to change per particle attributes. Making a dynamic membrane with surface proteins Creating a softbody membrane As we've done before, we'll create a simple softbody membrane from a NURBS plane made into a softbody. Create a NURBs plane with a width and length of 100 and with 20 patches in U and V. With the plane selected, select Soft/Rigid Bodies > Create Soft Body in the dynamics menu. With the softbody particles selected, create a new turbulence field. In the channel box, change the attenuation to 0, the magnitude to 200, and right click on phasex to create a new expression (select 'expressions... in the popdown menu). Write the following expression: Creating an expression in the expression editor. phasex = phasey = phasez = noise(frame); then press 'create' and play the animation. To get the membrane even more dynamic, change the goal weight of the membrane softbody particles to 0.3. You should have a very dynamic, wavy membrane as shown in the image on the right. Creating a softbody membrane with lots of turbulence. Using constraints to attach proteins to the membrane With the membrane this bouncy and dynamic, its very obvious that the receptor isn't moving along with the membrane. To attach the receptor 11

12 complex to the membrane, we'll be using some more constraints. First, we need to make sure that everything that we'll want to move with the receptor complex is in the same group as the complex. This will ensure that the animated Tf molecules and the receptor will move together. In the outliner, select your TF1/Tf2 locators,the motion path curve and curve copy (probably named 'curve1' and 'copyofcurve1' and right-click drag them into the TfR_ribbonGroup. Now select the membrane, then shift-select the TfR complex group. Under the animation menu, select Constrain > Geometry. Play the animation. You should notice that the complex is now moving up and down along with the membrane. To have the complex be aligned perpendicularly to the membrane surface, we'll use a normal constraint. With the membrane and complex selected, select Constrain > Normal and select the options box. Make sure the aim and up vectors are set to (as shown on the right). You should notice now that the complex moves and rotates with the surface of the membrane. Take a look at the transferrin that's moving along the motion path. If it appears as though it is offset from the path, this is due to a double transformation that we inadvertently created when adding the motion path curve to the TfR group. The transferrin is being rotated/translated by the motion path, which is now parented to the complex group, in addition to the transferrin group itself. To fix this, remove the Tf molecule from the TfR group by middlemouse dragging it out of the group in the outliner, as shown on the right. Grouping items before applying the constraints. Settings for the normal constraint. A double transformation has caused our transferrin to go off course. Creating a particle disk cache You may have noticed that when you try to scroll through the timeline, the softbody membrane behaves erratically. We can create a particle disk cache to get around this issue, which will essentially sets a keyframe for each particle in the softbody. Removing the transferrin from the group fixes the problem. 12

13 Rather than starting with a completely smooth membrane, it would also be nice to have the membrane look perturbed from the beginning. To do this, play the timeline to a frame that you like, and with the membrane softbody particles selected, go to Solvers > Initial State > Set for Selected in the Dynamics menu. When you scroll back to the beginning of the timeline, the membrane should start at this state. Next, with the particles of the membrane still selected, go to Solvers > Create Particle Disk Cache. You should now be able to scroll back and forth in the timeline without any of the membrane issues we saw before. Scrolling through the timeline without disk caching causes softbodies to behave erratically. Using MEL to populate the membrane with receptors For the next part of the tutorial, we will distribute copies of the transferrin receptor complex over the membrane. Create a duplicate of the receptor complex at frame 100 (when all of the Tf molecules should be bound). Select the TfR_ribbonGroup and the Tf2 we took out of the group and press ctrl+d to duplicate. Since these are just background molecules, we can leave out the ribbons and iron molecules. Rename the duplicated group 'background_tfr.' Delete the start/end locators, iron atoms, curves, constraints and ribbons from 'background_tfr' and place the ungrouped Tf molecule into the group. You can rename items if you like. Your background_tfr hierarchy should look like the image on the right. The background molecule with all extraneous pieces removed. Set the transform and rotation of background_tfr to zero. Open the script editor by selecting Window > General Editors > Script Editor. We're going to write a short script that will make duplicates of 'background_tfr,' distribute them along the X and Z axis, rotate them a little (so they aren't all facing the same direction) and then use geometry and normal constraints to attach them to the membrane. To see the commands in MEL, we simply have to run the commands and take a look in the script editor to see the commands. Commands automatically appear in the script editor as you use Maya. 13

14 Select background_tfr and press ctrl+d to duplicate. Next, move the duplicate (probably named 'background_tfr1' around in X and Z. Select the membrane, then shift-select background_tfr and create geometry and normal constraints as we did before (make sure the normal constraint options are set as we had them earlier). You should notice that the following commands (or variations thereof) appeared in the script editor: select -r background_tfr; duplicate -rr; move -r ; select -r nurbsplane1; select -add background_tfr1; geometryconstraint; normalconstraint; The way MEL generally works is that the command (select, duplicate, move, etc) is followed by one or more flags (-r, -rr, etc) that specify how the command should be run. We basically want to use these exact commands in a loop to place copies of background_tfr on the plane. Type in the following script.: for ($i = 1; $i <= 10; $i ++) { duplicate -rr -name ("new_tfr_" + $i) background_tfr; move (rand(-50,50)) 0 (rand(-50,50)) ("new_tfr_" + $i); geometryconstraint "nurbsplane1" ("new_tfr_" + $i); normalconstraint -aimvector "nurbsplane1" ("new_tfr_" + $i); } If your membrane is not called "nurbsplane1" make sure to replace that text with whatever your membrane is named. To run the script, press ctrl+enter in the script editor. You should see that now we have 10 copies of our background_tfr complex, named "new_tfr_1" through "new_tfr_10." Let's walk through the script. for ($i = 1; $i <= 10; $i ++) { } This creates a loop, starting at 1, and ending at 10. So, anything within the curly brackets will get repeated 10 times. The dollar sign always indicates a user-defined variable, which in this case, is implicitly defined to be an integer (variables may also be strings, floats, or booleans). After running the script, you should have 10 copies of the receptor complex, each geometry and normal constrained to the membrane. duplicate -rr -name ("new_tfr_" + $i) background_tfr; 14

15 This command is the duplicate command with a couple extra flags. The -name flag indicates what the name of the new duplicate will be. Here we are adding a string (new_tfr) to the loop number ($i), ensuring that each new duplicate has a unique name. For the first loop, for example, the name would be set to "new_tfr_1" since $i = 1. The last piece (background_tfr) determines what is being duplicated. move (rand(-50,50) 0 (rand(-50,50)) ("new_tfr_" + $i); The move command expects three numbers, corresponding to distance in X, Y and Z respectively. Here, since we are using the "rand" command to scatter the complexes. rand(- 50,50) tells Maya to choose a random number between -50 and 50. We only want to scatter along the X and Z axes, not the Y (which is set to 0). The last piece ("new_tfr_" + $i) tells Maya what is receiving this move command. geometryconstraint "nurbsplane1" ("new_tfr_" + $i); The first string after the command ("nurbsplane1") determines the object that does the constraining, while the second string ("new_tfr_" + $i) determines the target that will be constrained. normalconstraint -aimvector "nurbsplane1" ("new_tfr_" + $i); For the normalconstraint, I decided to use the flag '-aimvector' to set the aim vector to (which we had done manually earlier, using the options box). The last two strings determine the constrainer and constrained, similar to the geometry constraint. To get more information on MEL commands and possible flags, check out the MEL command reference (Help > MEL Command Reference). One problem you may have noticed with our distribution of complexes is that they're all facing one direction. If you try to change the rotation of a complex, you'll find that the rotation is being controlled by the normal constraint, so it cannot be changed directly. By going back and tweaking our original background_tfr, however, we can get around this problem. Delete all of the "new_tfr..." duplicates. In the outliner, expand the hierarchy of 'background_tfr.' Select everything in the hierarchy, and press ctrl+g to create a new group. Name the group 'rotatetfr.' Your hierarchy should appear as shown on the right. We'll now edit our script to include a random rotation. Creating an extra group node to address the lack of rotational diversity of the background complexes. for ($i = 1; $i <= 10; $i ++) { duplicate -rr -name ("new_tfr_" + $i) background_tfr; move (rand(-50,50)) 0 (rand(-50,50)) ("new_tfr_" + $i); rotate 0 (rand(0,360)) 0 ("new_tfr_" + $i + " rotatetfr"); geometryconstraint "nurbsplane1" ("new_tfr_" + $i); normalconstraint -aimvector "nurbsplane1" ("new_tfr_" + $i); } 15

16 So what exactly does our new line do? rotate 0 (rand(0,360)) 0 ("new_tfr_" + $i + " rotatetfr"); Similar to the 'move' command, the rotate command expects three values, corresponding to the rotation in X, Y and Z respectively. For our complexes, we only want to rotate randomly along the Y axes, so we set that to be randomly chosen (between 0 and 360). The X and Z rotations are set to 0. The last string determines what the rotate command is acting on. The " " is a way of indicating an object that is found within the hierarchy of another object. Here, we are saying that we want to act on the object named "rotatetfr" that is a child of the "new_tfr_" + $i object. After running the new script, the complexes have random distributions and rotations. Extracellular Matrix with particles & expressions This section of the tutorial is based on a section of a masterclass given by Eddy Xuan (AXS Medical Illustration Studio & U. Toronto) during Siggraph Thanks Eddy! The basic idea here is to use the trajectory of a particle path to create geometry, which in this case, will represent long polymers of the extracellular matrix. First, hide everything in the scene except for the dynamic membrane so we can focus just on the ECM. To get an idea of how a curve is drawn using MEL, with the script editor open, go to Create > CV Curve Tool and draw a curve with at least 4 CVs. Press enter to finish the curve once you've finished drawing points. The main part of the command should look like this: curve -d 3 -p p p p p (...) The "-d" flag refers to the smoothness (degree) of the curve. A value of 0 would give a linear, jagged curve, while 3 gives a smooth curve with 3 degrees. "-p" and the series of three digits is the location of each CV (point) of the curve. The values indicate where you clicked as you drew the curve in X, Y and Z. Delete the curve, as we only drew it to take a look at the MEL. To create our particle system. We'll use a NURBS cylinder as a particle emitter. Create a NURBS cylinder and scale it such that its diameter is slightly larger than the area of the membrane, and with a relatively short length (see image on right). The idea here is to have Create a large, short cylinder that will be the particle emitter. 16

17 this cylinder emit particles that will move across the diameter of the cylinder. With the cylinder selected, in the dynamics menu, go to Particles > Emit from Object, and open the options box. Change the 'emitter type' to surface, and increase the rate to Under the 'basic emission speed attributes' change the speed to 20 and the normal speed to -1. Then select 'Create.' When you play, you should see lots of particles being emitted towards the center of the cylinder. We really only want around 50 particles (each will make one ECM filament). To do this open the attributes of the particle and scroll down to the 'Emission Attributes' tab. Change the Max count to 50. The point here is to have all 50 particles emitted nearly simultaneously (which is why we increased the rate of particle emission of the emitter). Rename the particles "ECMparticles." Next, we'll use some MEL to have each of our particles create a curve. Double click on ECMparticles in the outliner to open its attributes. Change the emitter options for the cylinder. Changing the max count for the particles in the particle attributes. Scroll down to "Add Dynamic Attributes" and click on the "General" button. In the window that opens, give the new attribute the name 'makecurve,' and select 'per particle (array)' as the attribute type. Make sure that 'add initial state attribute' is ticked. When you return to the ECMparticles attribute, you should see that the 'makecurve' attribute now appears in the 'per particle (array) attributes. If you don't see this new attribute, try closing the attribute editor and reopening it. Creating a new per particle attribute called 'makecurve.' Right click in the text box next to 'makecurve' and select 'runtime expression before dynamics.' In the expression editor that opens, type in the following expression: The new 'makecurve' attribute 17

18 vector $loc = worldposition; if (frame == 5) { curve -d 3 -n ("curve" + particleid) -p ($loc.x) ($loc.y) ($loc.z); } if (frame%10 == 0) { curve -a -p ($loc.x) ($loc.y) ($loc.z) ("curve" + particleid); } Double check your typing, and press 'create.' If you get an error, you should look over your expression again and make sure it's correct. Rewind to the beginning of the timeline and press play. What you should see is that as the particles are emitted, their trajectory is made into a curve. In the outliner, you should a long list of these new curves, named "curve" and some number. Let's go back over the expression to figure out what it's doing. vector $loc = worldposition; Our expression at work: creation of 50 curves from particle trajectories. This creates a new vector variable. Vectors are defined as having three values, one for X, Y and Z. This new variable is called $loc, and is assigned the X, Y and Z coordinates of the particle (the worldposition attribute is one that all particles are born with). if (frame == 5) { curve -d 3 -n ("curve" + particleid) -p ($loc.x) ($loc.y) ($loc.z); } It is important to note that runtime expressions are evaluated on every frame for every particle. This expression checks what frame the animation is on, and if the frame number is equal to 5, will run the expression to create a curve. The -n flag gives the curve a name, in this case, "curve" and the particle Id number, which is unique to each particle being emitted. This ensures that each curve will be given a unique name. The -p flag indicates where the first point should be. Vector values, as for our vector variable $loc, may be called using ".x", ".y" and ".z" if (frame%10 == 0) { curve -a -p ($loc.x) ($loc.y) ($loc.z) ("curve" + particleid); } This final expression tells Maya to create a new CV for each curve at every 10th frame. "frame%10" means the value of the remainder of the frame number divided by 10. This value will be equal to 0 at frame values of 10, 20, 30, etc. To continue drawing points on pre-existing curve rather than making a new one, we're using the "-a" flag (short for "append"). This requires us to specify which curve we're adding to, which is why we've included the name of the curve at the end of the expression. 18

19 One of the issues with our current expressions is that if we re-run the simulation, new curves are created. We need to include a way to delete pre-existing curves. First, delete all of the curves. Next, open the ECMparticles attributes, and like before, right click next to the 'makecurve' text in the per particle attributes section, but this time click on "creation expression." The expression editor should open again, but the 'creation' radio box should be checked (as shown on the image on the right). Creation expressions are only run once, when the particle is first born. In contrast, runtime expressions, as mentioned earlier, are evaluated at every frame. Note the location of the 'creation' button (boxed in red) in the expression editor. Type in the following expression: if (`objexists ("curve" + particleid`) { delete ("curve" + particleid); } Press the "create" button at the bottom of the expression editor. What this expression does is to look for whether any objects with the name "curve" and the unique particle identifier already exist. If they do, the objects are deleted. The particle trajectory curves after the addition of a turbulence field. Note that the curves are going through the membrane! You should now be able to rewind and replay the simulation and have the curves redrawn every time. Next, let's add some turbulence to have the particles create more interesting trajectories. With the particles selected, create a turbulence field and change the attenuation to 0. Increase the magnitude to 50. Now we have a new problem -- the curves are too wild, and are passing right through the membrane. One way to get around this problem is to make a collision plane for the particles to collide into. To do this, create a new NURBS plane, and scale it so that it is larger than the cylinder emitter. Move it so that it is above the membrane but slightly below the cylinder. To have the particles collide with it, select the particles, then the plane and in the dynamics menu, go to: Particles > Make Collide. Duplicate Creating two planes that will act as collision objects to keep the particles from going into the membrane or straying off too far. 19

20 the plane and move the duplicate above the cylinder and repeat. Now your particles and curves should be neatly contained between the two planes. Hide the planes so that they don't obstruct your view. All we have left to do is to make our curves into tube shapes. We can do this through extrusions. First, create a NURBS circle with a radius of 1. Select the circle, then shift select the first of your curves. In the Surfaces menu, go to Surfaces > Extrude and open the options. Make sure that the style is set to 'tube,' the result position is 'at path,' the pivot is set to 'component' and the orientation is on 'profile normal.' Press 'extrude.' Creating a tube by extruding a circle along the length of one of the curves. Great! We've got a tube. Now we only have to repeat that forty nine more times to get the rest of our tubes. Or, we could write a little script to do this automatically. Delete the extruded surface you just made. Open the script editor and make note of the command you ran to create the extrusion. Mine looks like this: extrude -ch true -rn false -po 0 -et 2 -ucp 1 -fpt 1 -upn 1 -rotation 0 -scale 1 -rsp 1 "nurbscircle1" "curve0" ; The important things to note here are the last two strings -- the "nurbscircle1" is the item that I am extruding, and I'm doing it along "curve0." To make the script a little simpler to write, we should rename the curves so that they don't jump around numerically. The easy way to do this is by using the 'rename' command. First, select all of the curves. Next, look for the 'line operations' section of the user interface (see image on right). This should be at the top right corner. Click on the black arrow and select 'Rename' from the drop down menu. Type in "extrudecurve1" and press return. All of the items that you had selected in the outliner should now be renamed, starting with extrudecurve1 - extrudecurve50. The 'rename' tool. Type the following into the script editor: for ($i=1; $i<=50; $i++) { extrude -ch true -rn false -po 0 -et 2 -ucp 1 -fpt 1 -upn 1 -rotation 0 -scale 1 -rsp 1 "nurbscircle1" ("extrudecurve" + $i); } 20

21 Note that the extrude command should be all on one line! You can simply copy and paste most of the command from your command history. Note also that you should replace "nurbscircle1" with whatever your circle is named. Note that you can scale the circle up and down to have thicker or thinner ECM strands. The finished scene, ready for shading and lighting. 21