RFRK for RenderMan®

RFRK for RenderMan© User Manual. Version 0.19 - Next Limit Technologies© 2009

1

“Without the RealFlow RenderKit, we never would have been able to push the fluid renders to the resolution and quality that we delivered on The Curious Case of Benjamin Button. The RFRK allowed us to deliver higher resolution and better-looking CG water than previ-

ously possible, and in far less time than traditional meshes would have required.“

Andy Cochrane – CG Artist, Asylum Visual Effects

RealFlow™ Rendering Toolkit (for RenderMan® and mental ray®)

RFRK for RenderMan®User Manual. Version 0.19


2

INTRODUCTION

Introduction, 3FlowMesher Overview, 4

Core/Splash Filter, 8Boolean operations, 10Motion Blur, 11Miscellaneous, 12RealWave, 12The magnitudes, 14Lazy compute (for Renderman only), 15Subdivisions, 15

FlowParticler Overview, 16Particle primitives, 16Multipoints, 17Core/Splash Filter, 17Operation Based on camera, 18Motion Blur, 20Magnitudes, 20

RENDERKIT FOR RENDERMAN

3d Platform connetivity, 22Introduction, 22Plugin Installation for RenderMan Artist Tools Manual, 22

Windows 32/64 bits, 22Linux 32 and 64 bits, 22Debian Packages, 23RPM Packages, 23Autoinstall Packages, 23

RAT Plugin Manual, 24FlowMesher, 25FlowParticler, 28Quick Start, 29

Plugin Installation for RenderMan Studio manual, 32RMS Plugin Manual, 33

FlowMesher, 33FlowParticler, 35Quick Star (RAT), 36

MayaMan connectivity, 38Houdini connectivity, 38

DSO/RunProgram Manual Configuration, 38

LICENSE MANAGER

License Manager Manual, 43Introduction, 43Adding a License, 43Usage, 43FAQs, 44


3

INTRODUCTION

The RealFlow RenderKit is a set of tools that has been designed to facilitate the complex task of rendering RealFlow™ fluids. The RenderKit enables you to generate procedural geometry at render time, in situations where you want a polygonal mesh representation from your fluid particles. It also provides you with tools for rendering individual fluid particles. The RenderKit will dramatically simplify and accelerate your workflow.

For the past decade simulation tools like RealFlow™ have been used to achieve realistic animation of fluids. Thanks to the exponential growth of computation power, these simulations have become more and more realistic, which has often meant that users have to deal with ever-increasing numbers of particles.

In a typical RealFlow™ workflow, the user creates a fluid simulation and exports the file sequences containing the particles which represent the fluid. When it comes to rendering, users are usually interested in having a polygonal mesh rather than particles. This involves another step in the workflow, where the polygonal mesh is generated in RealFlow™ and a sequence of files containing those polygonal meshes is produced.

This extra step in the workflow creates a significant storage restriction for the polygonal meshes, and yet another problem arises when millions of these particles or vertices have to be imported into a standard 3D application for rendering. Often these applications cannot cope with such a vast amount of data.

The RFRK provides two different tools that will help you to overcome the problems described above: FlowMesher™ to create and render the polygonal mesh from the particles; and FlowParticler™ to render the particles.


4

FLOWMESHER OVERVIEW

Meshing is the internal process by which FlowMesher™ converts the particles into a mesh geometry. Various parameters, such as scale, resolution, smoothness, radius and polygon size are taken into account during the meshing process. To get the perfect look for the fluid, it is very important to configure these parameters correctly. For instance, to get a fluid with high/low detail, the resolution, scale or polygonSize parameters must be configured accordingly. These parameters configure the size of the polygons that make up the fluid mesh.Specifying high values for the resolution parameter will give you smaller values for the polygon size of your mesh and vice versa. It is critical that the scale parameter in the RFRK is IDENTICAL to the scale value in your scene in RealFlow.

To find the optimal resolution value, you could start by trying with the same value as your emitter in the RealFlow scene (i.e. FlowMesher resolution = 1.0 x RFemitter). If you want a more detailed mesh, try something like FlowMesher resolution = 10.0 x RFemitter (always leaving the scale parameter constant).Using the resolution and scale parameters is a quick, easy way to configure the level of detail for the fluid mesh.

Scale = 1 (Scale in RF scene); Resolution = 1 (RFemitter = 1) Scale = 1 (Scale in RF scene); Resolution = 1 (RFemitter = 1)

Scale = 1 (Scale in RF scene) Resolution = 10 (RFemitter = 1) Scale = 1 (Scale in RF scene) Resolution = 12 (RFemitter = 1)


5

Alternatively, you can configure the size of the polygons manually by using the polygonSize parameter.(This parameter is also related to the resolution parameter.) To configure this parameter correctly, start by considering the dimensions of your fluid. This parameter is indicated in world units. If the polygonSize

parameter is greater than zero, the scale and resolution parameters will have no effect on the appearance of the mesh. The images below show the effect of changes in polygonSize. If you use a low value for the polygonSize, the render will be slower because of the resolution increment of polygons in the geometry.Another key aspect involved in the final appearance of the mesh is the level of smoothness used – i.e. whether you are looking for smooth- or blobby-looking fluid. For this, you will have to configure the smooth parameter. This parameter tells the algorithm how far it should go to gather environment information to compute a given point of the mesh. The further the algorithm goes to gather information, the smoother the surface will be. Bear in mind that using high values in the smooth parameter will greatly increase computation time. Thus, the smooth parameter is the distance of search radius and is related to polygonSize. For the same value of smooth, this search distance will vary depending on the resolution you are using (see Figures 1, 2, and 3 for further explanation of this concept).

The best way to get great results is to follow this golden table:

Polygon size = 3 RFemitter = 60 Polygon size = 5 RFemitter = 60

FlowMesher parameters (golden table)

Resolution Smooth

1.0 x resemitter10.0 x resemitter

0.30.5

Polygon size = 0.5 RFemitter = 60 Polygon size = 1 RFemitter = 60


6

If you follow this table, the internal smooth distance will be fairly constant:

resemitter = Resolution of RealFlow emitter

Figure 1 shows how the mesh resolution works with values of 1.0 *RF emitter resolution. For example, if your emitter has a resolution value of 5, you could use this value in the RenderKit resolution parameter. Figure 1 shows the smooth values which would give you the optimal result.

In Figure 2 below you can view the values for resolution when multiplied by 10 - i.e. the Mesh Resolution would be (10 * RF emitter resolution). As in the last example, if your RealFlow emitter has a resolution value of 5 and the RenderKit is set to 50, the optimal value for the smooth parameter would be 0.5.

In Figure 3, the value for resolution is (Mesh Resolution = 0.5 * RF emitter resolution). In our example the RenderKit resolution parameter is 2.5 and, for optimal results ,the smoothing value is 0.2.

Figure 1 Figure 2

Figure 3


7

The table below gives you some examples of how the smooth and resolution parameters work in each case. Smooth and mesh resolution are directly related to getting a good final mesh.

Resolution Pol.size Scale Radius Smooth Core Splash MaxVel Image10*RFemitter= 50 0.0 1.0 0.4 0.0

no smoothing 0.0 0.0 1000.0

10*RFemitter= 50 0.0 1.0 0.4 0.3somesmoothing

0.0 0.0 1000.0

10*RFemitter= 50 0.0 1.0 0.4 0.5Optimal

0.0 0.0 1000.0

1*RFemitter= 5 0.0 1.0 0.4 0.0no smoothing

0.0 0.0 1000.0

1*RFemitter= 5 0.0 1.0 0.4 0.3Optimal

0.0 0.0 1000.0

1*RFemitter= 5 0.0 1.0 0.4 0.5Aggressive

0.0 0.0 1000.0

0.5*RFemitter =2.5

0.0 1.0 0.4 0.0no smoothing

0.0 0.0 1000.0

0.5*RFemitter =2.5

0.0 1.0 0.4 0.25Optimal

0.0 0.0 1000.0

0.5*RFemitter =2.5

0.0 1.0 0.4 0.3Aggressive

0.0 0.0 1000.0


8

There is one more parameter involved in the appearance of your mesh: the radius. The fluid is represented by particles that don’t have any real volume in 3D space. With the radius parameter, therefore, you can assign a volume (or radius of the sphere) to the particles.So, with this parameter you indicate the thickness of your fluid. It is measured in distance units relative to the resolution of the mesh, and is indicated in the following way:

Radius = 0.0 ( represents a sphere with a radius which is half of the resolution of the mesh)

Radius= 1.0 (represents a sphere with a radius which is twice the resolution of the mesh)

The default value for radius is 0.4The images below show how to modify the meshing parameters to get good results in your scene.

Core/Splash Filter

The Core and Splash filter method allows you to isolate particles based on the number of neighboring particles they have. In this way, you can either eliminate particles, or mesh them using different parameters from the main body of particles. With the Core parameter, you can isolate the core of the fluid from the rest. The range of values goes from 0 (does not remove the rest of the fluid) to 1 (removes all the rest of the fluid, leaves only the core). Similarly, the Splash parameter isolates the splashes from the rest of the fluid body. Like the Core parameter, its values range from 0 to 1. The examples below shows the behavior of the filter parameters

radius = 0.1 radius = 0.4

radius = 0.7 radius = 1


9

working in a simple mesh from a circular emitter.

This table represents adjustments to obtain the ideal result for the mesh, using Core and Splash filters combined with various meshing parameters. Note that Resolution 5 is the RF emitter resolution in this case.

Resolution Pol.size Scale Radius Smooth Core Splash MaxVel Image5.0 0.0 1.0 0.4 0.0 0.0 0.0 1000.0

5.0 0.0 1.0 0.4 0.0 0.2 0.0 1000.0

5.0 0.0 1.0 0.4 0.3 0.2 0.0 35.0MB On

5.0 0.0 1.0 0.4 0.0 0.0 0.0 1000.0

core = 0 core = 0.2 core = 0.5

splash = 0 splash = 0.8 splash = 1


10

Resolution Pol.size Scale Radius Smooth Core Splash MaxVel Image5.0 0.0 1.0 0.4 0.0 0.0 0.8 1000.0

5.0 0.0 1.0 0.4 0.0 0.0 0.9 1000.0

Boolean operations

Boolean operations are possible with the RenderKit. You can add as many fluids as you want to the scene. The appearance of continuity will be created by mixing the different fluids in the scene so that they make up the same mesh. So you can add fluids with the different elements from RealFlow like emitters and RealWaves. The method for adding new fluids will vary depending on whether you are using a 3D platform or a command line.

Figure 4 shows a example of how to add a fluid to a RealWave object. (Please note: RealWave properties will be explained later.) Figure 5 shows various emitters making one mesh from the four different fluids in the scene.

In the same way that you can add fluids to make a single mesh, you can also subtract fluids from the mesh.

Figure 5. Four emitters loaded into the sceneFigure 4. RealWave and two fluids loaded into the scene

Four emitters loaded with emitters 2 and 4 as subtractive fieldsFigure 5. Four emitters loaded into the scene


11

Motion Blur

Motion blur helps to increase the realism of the scene and give a sense of scale. You can achieve very realistic results by adding motion blur to your renders. The RealFlow RenderKit contains several parameters to control the appearance of motion blur, such as maxVel, shutter or frames. You can see the render with Motion Blur activated or deactivated in the images below:

Motion Blur can be controlled by the parameter maxVel, which allows you to clamp the module of the velocity of the particles to this value. In other words, if the velocity modules of the particles are higher than the maxVel value, the velocity module for each particle will be replaced by this value . This is a way to control the quantity of motion blur in the fluid render. By indicating low values for maxVel, you can see subtle motion blur in the

render. The following images show low values in the maxVel parameter.Don’t forget to set the frames per second (24, 25, 30 fps) in the scene, using the fps parameter, to get the right motion blur values.

motionBlur = OFF motionBlur = ON

maxVel = 0 motionBlur=ON maxVel = 10 motionBlur=ON


12

Miscellaneous

By default, the mesh will always have its normals facing the right direction, but if you need to invert them, simply use the flipNormals setting.

Another important issue here is which axis configuration to import the mesh with. When you import the mesh to your 3D application, the mesh will automatically be imported with the appropriate axis configuration for the 3D platform (be it 3DStudio Max or Maya), but if you wish to change this, you can specify a particular axis configuration. Your options are YXZ, ZXY and YZX.

RealWave

RealWave objects created in RealFlow can also be meshed by the RenderKit, just like RealFlow fluids. The RenderKit tessellates the RealWave mesh internally, using the Tesellation parameter. It uses the value of the tessellation parameter to calculate the number of particles per polygon. So, to increase the resolution for a RealWave mesh you simply modify the rwTessellation parameter. The default value for rwTessellation is 3. This indicates how the particles are distributed in each polygon of the RealWave mesh. The image below illustrates how the distribution of particles works.

flipNormals = NO flipNormals = YES

ZXY (3ds Max axis system) YXZ (Maya system) YZX (LightWave system)


13

Each particle is distributed in the RealWave mesh polygon according to the value for rwTessellation. To get optimal results for the RealWave mesh, you must take the smooth values into account when selecting a value for the rwTesselation parameter.

In this table below you can see different values for the RealWave mesh.

Resolution rwTessellation Image1.0 3.0

1.0 5.0

10.0 5.0

10.0 10.0

NOTE: The rwTesselation parameter only affects the realwave_file. The realwave_file can be mixed with the reaflow_file to generate a seamless mesh.


14

The magnitudes

These values enable you to interpolate the attributes of the particles to the vertex of the mesh. These values can be read by a surface shader. NOTE: In Renderman you can export several parameters at the same time.

Magnitude Primitive Var. Name Var.Interpol. Description velocity velocity varying The 3D velocitytexture s,t (globals) varying The texture coordinatesforce Force varying The 3D forceage Age varying The ageneighbors Neighbors varying The number of neighbors of a particleisolation Isolation varying How long a particle is isolatedviscosity Viscosity varying The viscositypressure pressure varying The pressuremass mass varying The massdensity Density varying The densitytemperature temperature varying The temperaturevorticity vorticity varying The 3D vorticity

Table 1: Magnitudes of the particles that can be transferred to the vertex of the mesh, the primitive variable names which will be attached to the mesh, and the type of variable. Below there are various examples of particles rendered with the RealFlow RenderKit and Renderman, using the magnitudes in the shading.

Magnitude Age Magnitude Force


15

Lazy compute (for Renderman only)

When you are working with heavy meshes, it can be time-consuming to calculate the mesh of the fluid every time you want to modify a parameter for your material. Lazy compute avoids this process by exporting the mesh to RIB file.

LazyCompute is a process in which you export the mesh to RIB files so the mesh will not be passed to the renderer. It will simply be exported and no geometry will be computed.

Subdivisions

Generating very high resolution meshes can cause problems with memory management. FlowMesher can handle these meshes by making volume subdivisions automatically.

Subdivision is the process by which the bounding box of the RealFlow particles is subdivided into several subvolumes, so each one computes the mesh independently. When all the subvolumes have been computed, the individual meshes are reunited to form a complete high-resolution mesh. In this way, these type of meshes can be rendered easily with low memory consumption. Although the RealFlow RenderKit generates this subdivision internally, you also have the option to control this process manually.

Magnitude Pressure Magnitude Velocity

flipNormals = NO


16

FLOWPARTICLER OVERVIEW

FlowParticler™ feeds the renderer with particle information from RealFlow™ BIN particle files.

Features:

• Generation of points, sprites and spheres at render time with configurable parameters.• The attributes of the particles are attached to these geometry primitives as primitive variables. These

attributes can be accessed and used by the shaders in the renderer.• Motion Blur is configured according to the overall setup of the scene.• Particle size relative to camera distance• Allows random variation of particle size• Multi-point technology to increase the number of particles at rendering time. You can use different

seeds to boost the number of particles by creating different passes.

Particle primitives

With FlowParticler you can render huge numbers of particles or instanced objects and control particle size with the min/max size parameters.

sprites points

spheres min/maxSize = 0.001/0.06


17

Multipoints

FlowParticler lets you create multi-points to increase the number of particles at render time. You can render different passes with different seeds, using the MPSeed parameter, to create more variation in the scene. You can control the number of particles with the MPDensity parameter, and adjust the volume around the particle where the new particles will be dispersed by adjusting the MPDispersion parameter.

Core/Splash Filter

The Core and Splash filters (controlled by the Core and Splash parameters) allow you to isolate particles based on the number of neighbors around that particle. So, for instance, you can render the splash particles with different parameters from the rest.

mpDispersion = 5 mpDispersion = 15

Original Render Using Splash Using Core


18

Operation Based on camera

By using this option, you can control the size of the particles based on their distance from the camera. There are three modes to decrease the size based on camera distance: linear, quadratic and cubic.

spheres


19

Distance Fall Off =5 Distance Fall Off =7.5 Distance Fall Off =10



‘Distance Fall Off’ indicates the distance at which the particles start to fall off.


20

Motion Blur

Motion blur depends on several camera and scene properties, such as the Shutter, the fps parameter and the units you are using (frames or seconds). You can clamp the motion vectors with the help of the maxVel parameter.

Magnitudes

The RenderKit can read the particle properties from RealFlow fluids, meaning that you can use them in your shaders, (for instance, mapping the opacity based on the age of the particle).

Mapping Opacity driven by Particle Age Mapping Pressure


21

Magnitude Primitive Var. Name

Var. Type Var. Interpolation Description Points Sprite/Sphere

velocity velocity vector varying uniform The 3D velocitytexture s,t (globals) float[2] varying uniform The texture coordinatesforce force vector varying uniform The 3D forceage age float varying uniform The ageneighbors neighbors float varying uniform The number of neighbors of a particleisolation isolation float varying uniform How long a particle is isolatedviscosity viscosity float varying uniform The viscositypressure pressure float varying uniform The pressuremass mass float varying uniform The massdensity density float varying uniform The densitytemperature temperature float varying uniform The temperaturevorticity vorticity vector varying uniform The 3D vorticity


22

RENDERKIT FOR RENDERMAN

The RFRK procedurals have been tested against the following Renderman compliant renderers: PRMAN - AIR - 3DLight - Aqsis – Liquid. There are two types of procedurals: DSO and RunProgram . The DSO has only been compiled against Pixar Pro Server Renderer, so if you want to use these procedurals in another RenderMan renderer you can only use the RunProgram command line version (which can also be used with PRMan).

There are two ways to include the procedural calls in the RIB file: you can use a 3D platform plugin, or include the calls manually.

3D PLATFORM CONNECTIVITY

Introduction

If you have a plugin that exports your scene to a RIB format file, you can use the scripts included in the package to facilitate the task. The scripts provided are for RenderMan Artist Tools for Maya and Renderman Studio for Maya. There are others plugins for Maya, such as MayaMan, and other 3D platforms, like Houdini, that allow you to load RenderMan procedural primitives.

Plugin Installation for RenderMan Artist Tools Manual

Windows 32/64 bits

The RealFlow RenderKit for Renderman comes with two versions of the installer – one for Renderman Studio, and another for Renderman Artist Tools users. The two versions are practically identical, apart from minor issues.

Prior to the installation of the RFRK you will need to install the latest RF Maya Plugins, which are available to download from the RealFlow customer download site. This new Maya plugin will install a shelf that will have standard import/export functionality for RealFlow workflow.

Linux 32 and 64 bits

For Linux™ there are three different installers. Two them (deb and rpm packages) will install the RenderKit in /opt/RealFlowRenderKitdirectory and will configure the Maya scripts automatically. ( Important: Maya® must

Linux 32 and 64 bits


23

be installed in its default directory , /usr/autodesk/maya*, where maya* can be maya2008, maya2008-x64, maya2009, etc.)If you want to personalize the organization of the directories, you will have to use the AutoInstall package. This way, you can configure your RealFlow RenderKit directory and the path to your Autodesk® Maya® directory.

Linux users will have to configure an environment variable (and add it to their initialization scripts). RFRTPROCEDURALDIR: this variable must point to procedural directories (i.e. if you install 64 bit RenderKit for RenderMan , with default settings, this variable must point to /opt/RealflowRenderKit/RenderMan-x64/procedurals).

Debian Packages

If you use Debian or Debian-like distribution ( Ubuntu, etc.):As the root, to install the RenderKit, simply enter: # dpkg –i rfrk-renderman-1.3.7.0035.deband to remove the RenderKit, enter:# dpkg –r rfrk-renderman

RPM Packages

If you use Linux™ distribution uses RPM packages you can install it by entering:# rpm –Uhv rfrk-renderman-1.3.7.0035.rpmTo remove it: # rpm –e rfrk-renderman

Autoinstall Packages

This auto-installation bash script enables the administrator to customize the setup. It has the following options:

Install: The administrator can choose where the RenderKit directory and the Autodesk® Maya® directories are located (-i, --install). The script will ask for these installation directories.Remove: The administrator can also remove the package (-r, --remove)Only extract tar.gz package: This enables you to just extract the tar.gz package (-x, --extract). In this case you will have to copy the script files (mel), the icon files (xpm), the mi templates (mi) and DSO files (so) manually. The tar.gz structure directory indicates where you should copy these files:The files in the icons folder should be copied to /yourmayapathdirectory/iconsThe files in the scripts/others folder should be copied to /yourmayapathdirectory/scripts/othersYou should add the two following lines at the end of the mel file /yourmayapathdirectory/scripts/startup/initShelf.mel:

catchQuiet(`evalDeferred -lowestPriority “rfrtRmsStartup”`);catchQuiet(`evalDeferred -lowestPriority “rfrtRatStartup”`);

Version: shows the version of the RenderKit ( -v, --version )


24

RAT Plugin Manual

RFRK Plugin . Installation Steps :


25

1.- Unpack the downloaded package.2.- Run the application. 3.- Choose the destination directory.4.- Select if you are installing 64 or 32bits DSO´s.5.- Select which version of Maya you want to install the plugin for.6.- Finish.

Two new icons will appear in the RealFlow Plugin shelf: one for RAT FlowMesher and one for RAT FlowParticler .

FlowMesher

It is fairly simple to read particles in RealFlow. Just go to the RealFlow shelf and click on the RAT FlowParticler icon. A file browser will open.


26

Select a file from a bin sequence. A dialog box will ask if you want to create an emitter to view the particles in the viewport. This can be useful to check their current position in the scene, but bear in mind that large files may take an long time to load and can cause memory problems. Within the nodal structure that will be created, you will have an LOD option in the emitter node to avoid memory overload.

This is the appearance of the node hierarchy of the particles when imported with RFRK:

If we now go to Slim, a new palette “RealFlow RenderKit” will appear, and inside this palette you will now have a Flow_Mesher_Generator node.


27

Each FlowMesher can contain one or more bin sequences, but they will all share the same meshing parameters:

Procedural Type: You can either select RunProgram or DynamicLoad as procedurals.

delayedReadArchive: This tickBox helps to optimize the memory by loading the mesh subdivision to render only when it appears in the camera view.

Filename: This filename contains the path and file name of the sequence. Multiple files can be mesh together by separating them with commas ‘,’

File Extension: This combo allows you to load BIN or PD files.

Offset: You can give positive and negative offsets to the loaded sequences. It is a global offset, meaning that all the sequences will be offset by the same amount.

RealWave:

RealWave Filename: Load an sd file from a RealWave surface here, to mesh it with the emitters that you have loaded.RealWave Tessellation: Indicates the level of tessellation of the RealWave mesh. The Toolkit tessellates the RealWave mesh internally and indicates the number of particles per polygon.

ExportMesh: By selecting this option you can generate the mesh to be rendered and export it to a file. This way you can fine-tune the shading without having to calculate the mesh every time you hit ‘Render’. It’s important to note that the mesh won’t be rendered at the time of export.ExportMeshPath: This is the path where the generated mesh will be stored.LazyCompute: If you have this box active, the mesh won’t be calculated but loaded from a previously exported file. This way, you can speed up renders when fine-tuning the shading.LazyComputePath: This is the path which indicates the location of the stored mesh to render.

Mesh Attributes:

Primitive Type: The mesh that is generated can be a PointsPolygon mesh or a SubdivisionMesh mesh. Scale: This indicates the overall scale used in your RealFlow simulation. This parameter is critical and must be set to the same value you used in RealFlow.Resolution: Resolution of the fluid in the scene. A good starting point is to set the same resolution as in the emitter in the RealFlow scene, and then experiment to get the look you want.

Scale parameter in SlimScale parameter in RealFlow


28

Polygon Size: Indicates the size of the polygons in the mesh. If this parameter is greater than zero the previous parameters scale and resolution will not have any effect.Radius: Shows the blobbiness of the mesh (from 0 to 1). This is related to the resolution parameter.If you set it to 0, the radius of the particles will be 0.5 times the resolution, and if you set it to 1 the radius will be 2 times the resolution.Smooth: Indicates the smoothness of the mesh. In order to assign smoothness to the mesh you must put a value greater than zero (values range from 0 to 1). A good starting point is 0.3.Core: Isolates the core of the fluid from the rest. The range of values goes from 0 to 1.Splash: Isolates the splashes of the fluid from the rest of the fluid body. The range of values goes from 0 to 1.Max Velocity Module: When motion blur is active, this setting allows you to define the maximum velocity of the particles which will be affected by motion blur - in other words, it has a clamp effect over the motion vectors. Motion blur is controlled by the Shutter parameter and Render Globals settings.Flip Normals: Inverts the face normals of the mesh.

Subtractive: This is a string of 0’s and 1’s indicating additive or subtractive Boolean operations on the final mesh of the loaded particle sequences. So, for example, if you have three sequences loaded and you want the first two to be additive and the third to subtract from them, you should put “110” in this field (quotes not needed).

Properties: You can use the particle properties exported from RealFlow to help with the shading of the mesh. (E.g. drive the transparency of a mesh based on the age of the particles.)

FlowParticler

The way to load particles to render is similar to method used with the FlowMesher. This time, click on the FlowParticler icon. If you go to Slim, a new palette called “RealFlow RenderKit” will appear, and in this palette you will now have a Flow_Particler_Generator node. The parameters of the node are as follows:


29

Filename: The filename field contains the path and file name of the sequence. Multiple files can be meshed together; separate them with commas ‘,’ when you enter them.

File Extension: This combo enables you to load BIN or PD.

Offset: You can give positive and negative offsets to the loaded sequences. This is a global offset, meaning that all the loaded sequences will be affected in the same way.

Render Particle Properties

Particle Render Type: The particles can be rendered as points, spheres or sprites.Min Size: Min/Max Size will work as a random range for particle size when rendered. Min indicates the minimum size any particle will have.

Max Size: The maximum size of any given particle.

MultiPoint:Density: If this is higher than 0 the multipoint option is activated and a cloud of particles will be created around each individual particle. Indicates the number of particles created.Dispersion: This parameter defines how much the multipoint will be dispersed in space. mpSeed: To disperse the multipoint, a seed is used to set the multipoint in different positions, so you can get different results with different seed numbers. This is useful to get different passes of particles.

Camera: With the following parameters you can modify the size of the particles according to their distance from the camera.

Activate: Check box to decrease the particle size based on the particles’ proximity to the camera.Distance: The distance at which the particles will start to fade.Fall-off: Select between the linear, quadratic or cubic-type curves to fade the size of the particles.

Core: Isolates the core of the particles from the rest. The range of values goes from 0 to 1.Splash: Isolates the splashes from the rest of the fluid body. The range of values goes from 0 to 1.

Max Velocity: When motion blur is active, this parameter allows you to fix the maximum velocity of particles which will be affected by motion blur - in other words, it has a clamp effect over the motion vectors. Motion blur is controlled by the Shutter parameter and the Render Globals settings.

Magnitudes: You can use the particle properties exported from RealFlow to help with the shading of the mesh. (E.g. drive the opacity based on the age of the particles.)

Quick Start

This tutorial will illustrate how to get an image rendered quickly using the RFRK.This is a simple scene with two fluids. Make sure you have installed the latest version of the RealFlow Plugin for Maya.


30


31

1) In Maya, go to the RealFlow shelf and select the icon to create a FlowMesher Node.2) Load the bin file sequence corresponding to Fluid 1.3) Select Yes to create an emitter in the viewport.

Now you have two options: A) add Fluid 2 to the existing FlowParticler node by clicking the button:

Or B) repeat points 1-3, creating an independent FlowMesher. We recommend the first method to create a mixed mesh.

4) Set the Resolution and Scale to the same values you used in the RF simulation.

5) Assign a shader to the FlowMesher node or leave it as default. Here, we have assigned a Blinn material.6) Render the scene. You can see the progress of the meshing in the Output window. (Please bear in mind that the NL License Manager must be running when you render with the RFRK)


32

Plugin Installation for RenderMan Studio manual

RFRK Plugin - Installation Steps:


33

1.- Unpack the downloaded package.2.- Run the application.3.- Choose the destination directory.4.- Select if you are installing 64 or 32 bit DSOs.5.- Select which version of Maya you want to install the plugin for.6.- Finish.

You will see that new icons have been added to the RealFlow Plugin shelf - one for RMS FlowMesher and one for RMS FlowParticler .

RMS Plugin Manual

FlowMesher

It is easy to read RealFlow particles to mesh. When you select the FlowMesher icon, a browser opens.


34

Select one file from a bin sequence. A dialog box will ask you if you want to create an emitter to view the particles in the viewport. This can be useful to check their current position in the scene, but bear in mind that large files may take a long time to load and can cause memory problems.

This is the appearance of the particle structure as imported by the RFRK.

Particle SequencesAdd Sequence: This button allows you to add several bin sequences.

Sequence0,1,2…Path and Prefix: This field contains the path and file name of the sequence.File Type: This combo allows you to load BIN or PD.Offset: This parameter allows you to give positive and negative offsets to the loaded sequences.Subtractive: If you switch to subtractive mode, the mesh built with these particles will be used to create a Boolean difference operation between all loaded sequences.

Mesh AttributesMagnitude: In this field you can load particle properties to transfer into the shader properties of the built mesh (separating the properties with blank spaces). Scale: This indicates the global scale used in your RealFlow simulation. This parameter is critical and must be the same value as the one you used in RealFlow to get correct results.Resolution: Resolution of the fluid in the scene. A good starting point is to set the same resolution as in the emitter in the RealFlow scene, but you will have to experiment to get the look you want for the mesh.Polygon Size: Indicates the size of the polygons in the mesh. If this parameter is greater than zero the previous.

RealWaveRealWave: Load the .sd file from a RealWave surfaces here to mesh it with the emitters.Tessellation: Indicates the level of tessellation of the RealWave mesh. The RenderKit tessellates the RealWave mesh internally, indicating the number of particles per polygon.


35

FlowParticler

The method used to load particles to render is the same as in FlowMesher, except that you select the FlowParticler icon. The following are the specific parameters of the FlowParticler node

Particle FilesAdd Sequence: This button allows you to add several bin sequences.

Sequence 0,1,2…Path and Prefix: This field contains the path and file name of the sequence.File Type: This combo allows you to load BIN or PD.Offset: You can give positive and negative offsets to the loaded sequences.

Particle AttributesMagnitude: You can choose one property to transfer into the shader properties of the built mesh.


36

Max/Min Size: This indicates the maximum and minimum range for the random size of the particles in the render. If these values are set to be identical there will be no variation in particle size.Core: Removes the core of the particles from the rest. The range of values goes from 0 to 1.Splash: Removes the splashes from the rest of the fluid body. The range of values goes from 0 to 1.Max Velocity: When motion blur is active, this parameter allows you to define the maximum velocity of particles which will be affected by motion blur - in other words it has a clamp effect over the motion vectors. Motion blur is controlled by the Shutter parameter and Render Globals settings.FPS: Must be set to the frame rate in the scene: 24, 25, 30.etc.Multipoint Density: If this is given a value of more than 0, the multipoint option is activated and a cloud of particles will be created around each individual particle. This parameter indicates the number of particles created.Multipoint Dispersion: This parameter defines how much the multipoint will be dispersed in space. Multipoint Seed: To disperse the multipoint, the RenderKit uses a seed to set the multipoint in various different space positions, so you can get different results with different seed numbers. This is useful for getting different passes of particles.Distance Fall Off: Switches to Operations based on camera distance.Fall Off Scale: The distance at which the size of the particles starts to decrease.Fall Off Type: Select between the linear, quadratic or Cubic curve to fade the size of the particles.Motion Blur: The motion blur can be computed with the position of the particle in the next frame “interpolated”, or with the instant velocity of the particle “instant”. If you select “interpolated,” make sure that the next frame file exists.

Quick Start (RAT)

This tutorial will illustrate how to render an image quickly using the RFRK.This is a simple scene with two fluids. You will need to have installed the latest RealFlow Plugin for Maya.

1) In Maya, go to the RealFlow shelf and select the icon to create a FlowMesher Node.2) Load the bin file sequence corresponding to Fluid 1.3) Select Yes to create an emitter in the viewport.Now you have two options: A) add Fluid 2 to the existing FlowParticler node by clicking the button:


37

Or B) repeat points 1-3, creating an independent FlowMesher. We recommend the first method to create a mixed mesh.4) Set the Resolution and Scale to the same values you used in the RF simulation.

5) Assign a shader to the FlowMesher node or leave it as default. Here, we have assigned a Blinn material.6) Render the scene. You can see the progress of the meshing in the Output window. (Please bear in mind that the NL License Manager must be running when you render with the RFRK)


38

MayaMan connectivity

As MayaMan allows you to load generic DSO and RunProgram procedurals, it is easy to include the RFRK procedurals -FlowMesher and FlowParticler- in the MayaMan workflow. You will have to define the procedurals’ parameters in the “MayaMan procedural” node. To find out more about the parameters of these procedurals, please see the DSO RunProgram Manual Configuration section.

Houdini connectivity

Houdini supports RenderMan procedurals, so you can import RFRK procedurals. To find out more about the parameters of these procedurals, please see the DSO RunProgram Manual Configuration section.

DSO/RUNPROGRAM MANUAL CONFIGURATION

Here is a basic tutorial of how to edit a RIB file to make it work with the RFRK.

First, insert the procedural call inside the RIB file, where you want to include the fluid geometry. From a console, use your renderer of choice to render the modified RIB with the procedural call. If you are rendering with PRMan: c:\...\prman <fileName.rib>The top left-hand image shows the original file. The top right-hand image shows the modified file that will make use of the Realflow Renderkit procedural.

The bottom images show the corresponding renders.If you don’t set a parameter inside the argument line, the parameter value will be set to default automatically.


39

FlowMesher Parameters

The arguments of the procedural are:

-rfrk_meshName -rfrk_realflow_file -rfrk_realwave_file -rfrk_rwTesselation-rfrk_magnitudesBegin -rfrk_magnitudesEnd

-rfrk_primitiveType -rfrk_delayedReadArchive -rfrk_exportMesh

-rfrk_exportMeshPath -rfrk_lazyCompute -rfrk_lazyComputePath -rfrk_flipNormals-rfrk_scale -rfrk_resolution -rfrk_radius rfrk_polygonSize-rfrk_smooth -rfrk_core -rfrk_splash -rfrk_subtractiveField-rfrk_motionBlur -rfrk_shutter -rfrk_fps -rfrk_framerfrk_maxVel -rfrk_center -rfrk_diameter -rfrk_nxyzlevel-rfrk_currentSubVolume -rfrk_nSubVolumes -rfrk_axis

All the parameters are initially set to default values. Some of these parameters (rfrk_center, rfrk_diameter, rfrk_ nxyzlevel, rfrk_currentDivision, rfrk_nTotalDivision) can only be configured by the RenderMan Artist Tools plugin. Take a look at the previous images to see a practical example.Description of the parameters:

• rfrk_meshName( string ): name of the mesh• rfrk_realflow_file(string): In this field put the name of the PD or BIN file/s used in the simulation. If you

put more than one file, separate them with commas.• rfrk_realwave_file (string): path to your RealWave sd file.• rfrk_rwTesselation (integer): number of particles per RealWave face.• rfrk_magnitudesBegin / * rfrk_magnitudesEnd (string): In this block, put the magnitudes. These

options allow interpolation of the magnitudes of the particles to the vertices of the mesh as primitive variables. See the Magnitudes section of the manual for their names, variable types, and how they are interpolated from the vertices through the surface, etc.

• rfrk_primitiveType (string): the mesh that is generated can be a PointsPolygon mesh or a SubdivisionMesh mesh.

• rfrk_delayedReadArchive (string): if you want your generated mesh be loaded as delayedReadArchive or not (yes or no).

• rfrk_exportMesh (string): if you want to export the mesh as a RIB file (yes or no). The mesh will not be passed to the renderer, only exported. Then you can load it quickly with (rfrk_lazyCompute and rfrk_lazyComputePath) and no geometry will be computed. This is useful for shading purposes.

• rfrk_exportMeshPath ( string ): the directory to which the mesh will be exported• rfrk_lazyCompute (string): if you want to load an exported mesh (yes or no). This process also gives

you the option to optimize the work with Lazy Compute. You can indicate with exportMesh that you want to export the mesh to RIB file and use Lazy Compute to quickly load the exported mesh. You must indicate where you have stored the mesh in the hard disk. Both commands have corresponding paths (exportMeshPath and lazyComputepath) to indicate where the RIB files were saved. In order for exportMeshPath and lazyComputePath to work, exportMesh and LazyCompute must be active. You can also indicate if the loaded mesh will be procedural with delayedReadArchive. This is only available for Renderman, but if you are using RAT this parameter is not necessary because this plugin previously computes the mesh’s bounding box. (See the command line manual to find out more about lazyCompute parameters)

• rfrk_lazyComputePath (string): directory that contains the exported mesh.• rfrk_flipNormals(string): whether or not the normals should be flipped (yes or no). • rfrk_scale(float): the scale of your RealFlow simulation. This parameter is critical. • rfrk_resolution(float): We recommend that you start with the resolution parameter of your RealFlow


40

simulation and then experiment to get the look you want. • rfrk_polygonSize(float): size of the polygon or resolution of the mesh. If this parameter is greater than

zero the last parameters rfrk_scale and rfrk_resolution will not have any effect on the appearance of the mesh.

• rfrk_radius(float): the blobbinessof the mesh (from 0 to 1). This is related to rfrk_resolution. If you choose 0 the radius of the particles will be 0.5 times the resolution, and if you choose 1 the radius will be 2 times the resolution.

• rfrk_smooth(float): to make the mesh smooth, put a value greater than zero and experiment to get the appearance you’re looking for (from 0 to 1). This is also related to the resolution. For example, if the resolution of your emitter (in the RealFlow simulation) is 1, and your rfrk_parameter is 1, 0.3 would be a good smoothing parameter. If you want more smoothing, try increasing the resolution of your mesh. For example, if the resolution of the emitter is 1 and you want a more detailed mesh, choose an rfrk_resolution of 10 and an rfrk_smooth of 0.5. You must experiment to find the optimal values. However, be careful with this value because if you put an aggressive smoothing for a given rfrk_resolution the computing time can increase exponentially.

• rfrk_core(float): to isolate the core of the fluid from the rest, experiment with values from 0 to 1. • rfrk_splash(float): to isolate the splashes from the rest, experiment with values from 0 to 1. • rfrk_subtractiveField(string): With the subtractiveField parameter you remove the particles from the

loaded fluids emitters which have been told to be subtractive from the final mesh. This argument is a string of ones and zeros. One indicates that the field is positive and zero indicates that the field is negative. For example, if you have four emitters and you want the emitters 2 and 3 to represent negative fields you should put the string: 1001. By default, all the fields are positive. (See images below.)

Note: The numeration for subtractiveField mode depends on the order in which you load the fluids

Scale parameter in Slim Four emitters loaded (subtractiveField = 1010)

Three emitters loaded (subtractiveField = 111) Three emitters loaded (subtractiveField = 110)


41

• rfrk_motionBlur(string): if you are going to activate motion blur, put frames (if you have configured the motion blur in frames) or put seconds (if you have configured it in seconds). And if you are not going to use motion blur put no.

• rfrk_shutter(float[2]): the first float indicates when the shutter opens (in seconds or in frames depending on how you have configured the rfrk_motionBlur parameter), and the second float indicates the shutter angle in degrees.

Another important aspect to control the motion blur is the shutter. At 0.0, there is no motion blur. Increasing the value for shutter will also increase the amount of blurring. Depending on whether you are using 3D applications or command lines, the shutter value will be indicated in a different way (although the general concept for shutter parameters is the same). The first value for shutter indicates how much the shutter opens (in seconds or in frames depending on how you have configured the motionBlur parameter); and the second value indicates the shutter angle in degrees. If you are using a 3D application, the motion blur will be configured automatically. (See images below).

Note: Adjusting Motion Blur can increase the render time.

• rfrk_fps (float): frames per second • rfrk_frame (int): current frame• rfrk_maxVel (float): maximum velocity of the particles • rfrk_center (float [3]): If you are subdividing the mesh, this parameter indicates the centre of the

current “subvolume”. (Important: Please see footnote.)• rfrk_diameter (float [3]): the diameter of the current “subvolume”. Leave this parameter as (0.0,0.0,0.0)

to indicate that you want the DSO/EXE to subdivide the mesh and fill the parameters Center, Diameter, Nxyzlevel, currentDivision and nTotalDivision automatically.

• rfrk_nxyzlevel(float[3]): this parameter indicates how many meshes will be built and on which axis. For example, if you want to subdivide the mesh into three meshes along the Y axis, this parameter should be (1.0,3.0,1.0). If you want automatically generated subdivisions, leave this parameter at (1.0,1.0,1.0).

• rfrk_currentSubVolume(float): the number of current subdivisions, from 0 to nTotalDivision – 1.• rfrk_nSubVolume(float): the total number of subdivisions. • rfrk_axis(string): you can specify a particular axis configuration depending on your 3D platform. YXZ,

ZXY, YZX are the valid values depending on your 3D application.

MB= on; shutter= 0 MB= on; shutter= 0.5 MB= on; shutter= 2


42

FlowParticler Parameters

The arguments of the procedural are:

-rfrk_realflow_file -rfrk_magnitudesBegin -rfrk_magnitudesEnd -rfrk_renderType-rfrk_mpDensity -rfrk_mpDispersion -rfrk_mpSeed -rfrk_minSize-rfrk_maxSize -rfrk_core -rfrk_splash -rfrk_sizeFallOff-rfrk_distanceFallOff -rfrk_distanceFallOffSlope -rfrk_cameraPosition -rfrk_cameraUp-rfrk_motionBlur -rfrk_motionBlurType -rfrk_shutter -rfrk_maxVel-rfrk_fps -rfrk_axis

See the tutorial for examples.

Description of the parameters:

• -rfrk_realflow_file(string): In this field, put the name of the PD or BIN simulation file{s}. If you put more than one file, they must be separated by commas.

• -rfrk_magnitudesBegin / * rfrk_magnitudesEnd(string): In this block, put the magnitudes to export. This option allows the attachment of the magnitudes of the particles to the points, sprites or spheres as primitive variables.

• -rfrk_renderType (string): This parameter allows you to render the particles as points, sprites oriented to camera or spheres.

• -rfrk_mpDensity (float): If this value is greater than zero, multipoints will be enabled for points, sprites and spheres.

• -rfrk_mpDispersion (float): Dispersion of the new particles around the existing particle. This value is related to the rfrk_size parameter.

• -rfrk_mpSeed (int): Seed for the multipoint argument.• -rfrk_minSize (float): Minimum size of the points, sprites or spheres.• -rfrk_maxSize (float): Maximum size of the particles.• -rfrk_core(float): To isolate the core of the fluid from the rest, experiment with values between 0 and 1 .• -rfrk_splash(float): To isolate the splashes from the rest of the fluid, experiment with values between

0 and 1 .• -rfrk_sizeFallOff(string): If the value of this string is no, the size of the points, sprites or spheres is

constant. But if the value is yes, the size of the points, sprites or spheres will fall off according to their distance to the camera. (See the next two parameters.)

• -rfrk_distanceFallOff(float): Where the points, sprites or spheres start to fall off. • -rfrk_distanceFallOfSlope(float): How fast the points, sprites or spheres particles fall off (linear 0,

quadratic 1, cubic 2). • -rfrk_cameraPosition(float[3)]: Position of the camera to compute the fall-off. • -rfrk_cameraUp(float[3]): Camera up vector enables you to align the particle correctly.• -rfrk_motionBlur(string): If you are going to activate the motion blur put frames if you have configured

the motion blur in frames or put seconds if you have configured it in seconds. And if you are not going to use motion blur put no.

• -rfrk_motionBlurType(string): If you want to displace your particles according to their instant velocities to get motion blur use instant. And if you want to make the motion blur with the last and current frame positions use interpolated. The latter is more accurate. (Note the padding of the RealFlow files must be set to five.)

• -rfrk_shutter(float[2]): The first float indicates when (in seconds or in frames depending on how you have configured the *motionBlur parameter) the shutter opens; and the second float indicates the shutter angle in degrees.

• -rfrk_maxVel(float): Maximum velocity of the particles.• -rfrk_fps(float): Frames per second. This parameter has to be the same you used in RealFlow. • -rfrk_axis(string): You can specify a particular axis configuration depending on your 3D platform.YXZ,

ZXY, YZX are the valid values depending on your 3D application.


43

LICENSE MANAGER

LICENSE MANAGER MANUAL

Installation Manual

Introduction

The “License Manager” is the application that handles all the licenses of the RFRK and other products in a centralized and unified way. It is responsible for storing and managing all the licenses associated with any of the products that use the Next Limit network license policy. It also shows the license information and which machines are using the licenses.

Adding a License

You can add a license by selecting “New License” in the File menu. In the dialog box, copy in the license information as text, or select a license.txt file that contains the licensing information. This information, while valid, is stored internally by the License Manager. You should also keep all your license information and files in another location as a backup.

Usage

In order to use any of the products that need network licenses there must only be one “License Manager” running in the network where the clients are going to work. When you launch the application it will automatically start managing license petitions with the stored licenses in the system.

If another “License Manager” is running in the network the previous one will close automatically and show an error. The same “License Manager “ can work with different products that use the Next Limit network licensing policy. Using a different “License Manager” for each product won’t work.


44

The License Manager shows in a window which clients are using licenses, and of what kind, and the remaining licenses that can be used. (It will compile and use all the license texts you have been issued for any given product.) It also shows all the licenses stored in the system, and the information about every license. The usage of the licenses is linked to the number of machines. The same machine can ask for several licenses of the same product, which will be shown as “instances” in the usage view, but the machine will not be able to consume extra licenses.

If a client crashes or physically disconnects while a license is being used, that license will be tied to that computer. If the same computers restarts it will continue using the linked license. In order to unlink the license to the machine in use you will need to restart the License Manager.

FAQs

- I cannot start the license manager; it shows the port is already occupied.

If you have the License Manager running in your system, you cannot have any other application which uses port 2224 in your machine. The License Manager needs port 2224 to handle license petitions. You should disconnect the application running in that port or use another machine for the License Manager.

- My “License Manager” client cannot get a license and the License Manager is running

You must run the License Manager in the same sub-network (or machine) in which the client is located. If it continues to fail, check that you don’t have all your licenses already in use (which will be shown in the window).

- The “License Manager” shows a machine is using a license but the machine is switched off.

If that machine didn’t finish the work, or disconnected in any way, you will need to restart “License Manager” to free that license.

- I had a license with an expiration date and now it has disappeared from the list of licenses.

When a license has expired it is automatically removed from the list of licenses and from the “License Manager” stored licenses.

Documents

RFRK for RenderMan®