ICE Concepts and Workflows Part 1


Uploaded by SoftimageHowTos on 01.11.2010

Transcript:
ICE is a visual development environment for creating effects in Softimage.
If you want to begin with a preset particle or deformation effect and then modify it, you can use the commands on the ICE toolbar or menu.
But if you are building something from scratch, it can be difficult to know where to begin.
If you are new to ICE, it's best to choose something reasonably simple to learn the basic concepts and workflows.
In this two-part video series, we are going to create a simple deformation from scratch, going from a basic idea to a reusable compound.
We will use the proximity of the sphere's surface to move points on the grid along their normals.
Select the grid, open an ICE tree view, and create a non-simulated ICE tree.
ICE trees are added to the object's construction stack just like any other operator.
You can see the ICE tree's position in the stack in the local explorer on the right.
You build ICE trees by plugging nodes into the ICETree root to get, modify, and set data.
Deformations modify point positions, so you should start by getting the current point positions of the grid.
You can get an explicit reference to an object or property by dragging it from an explorer into the workspace.
This adds a Get Data node with the name already filled in for you.
Alternatively, you can type in the keyword "self".
"Self" refers to the object with the ICE tree and is useful for making ICE trees more portable.
Drag a blank Get Data node into the tree.
Nodes that cannot be evaluated are red.
In this case, you need to specify which data to get.
Connect its In Name port, and open its property editor by double-clicking.
Explore to get the PointPosition attribute.
Daisy-chaining Get Data nodes in this fashion allows you to get multiple attributes on the same object and easily change a single reference to that object later on.
The Value output port is yellow, indicating that it is a 3D vector.
Different data types have different colours.
Drag an Add node into the tree.
Its ports are black and its property editor is blank.
This is because it can accept multiple data types, and the data type to use hasn't been specified yet.
Connect the point positions to Value1.
All the other ports in the Add node become yellow to indicate that they are now 3D vectors.
In addition, Value2 appears in the property editor.
You can change values here, but they are not driving anything yet.
Add a Set Data node to set Self.PointPosition and connect it to the root.
You can specify the name and attribute directly in the Set Data node.
Or if you delete the reference in the node, you can daisy-chain the name and attribute.
However, if you daisy-chain just the "self" name and specify the "PointPosition" attribute in the node,
you can easily change the object reference and use the same Set Data node for other attributes on the same object.
Now you can use the sliders in the Add node to modify the point positions.
You can combine data as long as it's in the same context.
The context is basically the owner of the data, whether it's components like points and polygons, or the object itself.
Get Self.PolygonNormal and try to connect it to Value2.
The connection is refused because there is no one-to-one correspondence between points and polygons.
You can see the context of data by hovering the mouse over an output or input port.
Change the reference to PointNormal and you can now connect the value.
The points are moved one unit along their normals.
To get better control over the amplitude of the effect, drag a Multiply by Scalar node onto the link between PointNormal and Value2.
The new node is automatically inserted between the others.
This technique works with basic nodes but not compounds.
Basic nodes and compounds can be distinguished by their icons in the preset manager.
We'll talk more about compounds in the next video.
The Multiply by Scalar node provides a slider to control the amount of deformation.
At this point, it's worth noting that you can use the standard navigation keys in the ICE tree, such as Z and S, or Alt in Maya mode.
You can also automatically rearrange the selected nodes in the tree.
If no nodes are selected, the entire tree is rearranged.
Getting back to the deformation, so far we have an ICE tree that moves all points along their normals by a given amount.
You can get data from other objects; for example, you can control the deformation using the distance to the sphere's surface.
Drag a reference to the sphere into the tree.
If you rename the sphere to "ball", the reference in the ICE tree gets updated automatically.
If you delete the object, the node turns red.
But if you get another object and call it "ball", the node reconnects automatically.
Now add a Get Closest Location node. This will allow us to find the closest location on the ball for each point on the grid.
Connect the sphere to its Geometry input, and connect PointPosition into the Position input.
The output is the closest location on the ball's surface per point on the grid.
You can look up ICE data at locations.
Copy and paste the Get PointPosition node and plug the location into its source.
Use a Get Distance Between node to get the distance between the closest locations on the ball and the original point positions.
Plug the result into the Factor port of the Multiply by Scalar node.
This is not the result that we want.
The effect should get stronger as the ball gets closer, not the other way around.
Use a Rescale node to change from a range of about 0 to 10 to a range of 1 to 0 and clamp the values.
Now test the effect by moving the ball.
For additional control over the strength of the effect, add a Multiply node between them and adjust the slider.
To control the profile, you can use an FCurve node.
Since by default the FCurve node assumes that its input varies between 0 and 1, insert it right after the Rescale node.
We now have an ICE tree that deforms the grid based on the distance to the ball's surface, with additional controls for the strength and profile.
In part 2 of this video, we'll look at some of the tools for debugging ICE trees, and also show how to export and reuse a compound.