FrameForge VRML Object Setup/Importing

FrameForge VRML Object Importing

NOTE: This article is specific to VRML -- for importing of other object formats (Collada, FBX, Sketchup), see here.

FrameForge Previz Studio imports Optimized Meshes saved in the VRML Object Format (Versions 1 and 2) through FrameForge Previz Studios built-in converter.

An Optimized Mesh is one that is low-polygon with small textures, designed and modeled for real-time display with backface culling. More details on low polygon modeling can be found on-line or in computer books readily available at most bookstores.

Most 3D Modeling programs natively export in VRML format or have free or inexpensive plug-ins that will allow them to do so. Because of the widespread support of this format, FrameForge Previz Studio now has a built-in converter that will read any VRML object with the extension .wrl or .wrz and will convert it to FrameForge Previz Studios native 3DXF format.

In order to use a VRML object in FrameForge Previz Studio, make sure that:

1.       The Object was created with a low polygon count and only necessary textures

2.       The Object was designed to be displayed with Backface Culling on

3.       The Object was saved or exported in VRML format (which may also be called VRML 97,

or VRML Version 1 or 2)

4.       The Object has the extension .wrl or .wrz (which means it was gzip compressed)

To import it into FrameForge Previz Studio simply go to OBJECTS--> IMPORT 3D OBJECTS --> VRML or simply drag it onto the Object Library into the category where you want it to go.

After you tell the program that you want to import it, you will see the following dialog, though of course the names and dimensions will vary depending on the actual VRML file being imported.

Percent Size: Objects are often modeled using meters, so when you import them, they can be significantly out of scale with the rest of the FrameForge Previz Studio world. The first option on this dialog allows you to specify what scaling percentage the converter should use for this object, and it displays the resulting size in the boxed area at the top of this dialog.

Limit Textures: Since using large textures can greatly slow down the rendering, this converter allows you to set a maximum texture size so that objects will render quickly.

Remove Back-Facing: The most efficient rendering method, called Backface Culling, does not render the parts of an object that are facing away from the camera. However, if an object is not designed for this, pieces of it can appear invisible or inside out. Should this happen, the best thing to do is to go back to the original object and fix it so that it displays correctly with backface culling, then re-export it as VRML. Failing that, simply reimport the original VRML and uncheck this option.

Make Object Non-Colliding:FrameForge, they interact either by applying a relationship or one jumping on top of the other. If you have a large object or complicated that you want to place actors WITHIN then you may want to check this option.

Make Topography Object: A topography object is a special large-scale object--like a hill or landscape that floating cameras should slide above. ONLY use this on relatively simple objects as it is processor intensive.

Hinged VRML Objects

Native FrameForge 3D Objects typically have a variety of possible manipulations; you can change the colors of parts, add textures and move parts on hinges and sliders and even choose among several part options.

You can now do all these things in objects exported in the VRML format as long as your 3D modeling software supports named groups and exports them correctly to VRML and you use certain naming and structuring conventions described below.


Hinges consists of two parts, the  moving part that rotates around the hinge axis. Lets look at a safe, for example. The stationary part is the shell of the safe (labeled ), as shown to the righthe moving part is the door, its tumbler and the locking wheel as shown in the image at the bottom of the page

In order to define where the door rotates around the hinge, we add an axis object (which can be found in your FrameForge Previz Studio\Object Creation folder in a variety of formats) and format the parts into a Hinge Group which contains the axis and the parts affected by the axis and tells the importer how to convert and name these parts.

The axis object will automatically be removed when the object is converted from VRML to FrameForge Previz Studios internal format so you dont have to worry about its color or visibility.

To define a Hinge Group, create a group and name it ff3d_hinge_name followed by a group name, then a colon or dollar sign and the hinge name.

Thus, in our example safe object, the hinge group for the safes door will be named ff3d_hinge_name (safe$open door) as shown below.

This Hinge Group must contain exactly two objects. One of them must be the axis, positioned and oriented as desired and named ff3d_axis, the other must be either a single object which is to be affected by the hinge, or a group of objects, all of which are affected by the hinge.

The placement of the axis object defines the axis around which the moving parts will rotate. You can angle or size it as desired as long as you don't change its overall shape nor the number of faces and points.

Axis follow the Rule of Thumb which is if you take your right hand and point your thumb in the same direction as the pointy part of the axis then the direction in which you can bend your fingers is positive and the direction you cant bend is negative.

Thus by placing the axis pointing upwards at the end of the door, when the hinge is moved in a positive direction, the door opens.

If you want to limit the range of motion of this axis, simply add a minimum and maximum range to the doors axis name, like ff3d_axis (0,170) or, for the locking wheel, ff3d_axis(-360,360).

Since the position in which the object is currently placed is defined as zero degrees, the minimum of this range parameter must be zero or less, and the maximum must be zero or greater.

Thus, in our safe door example, we define the door hinge axis as having a minimum range of 0 (meaning it cannot be rotated in the negative direction), and a maximum range of 170 degrees in the positive direction.  

NOTE: if your VRML exporter complains about either the parenthesis or the comma, simply replace them with underscores _ as FrameForge Previz Studio can handle either syntax, the first is just more readable.

A hinge doesnt have to be at the edge of an object like a door, for example.

It can be in the middle of an object such as a wheel or bicycle handlebars and you can have nested hinges. Thus, in the above example, we have one hinge which affects the door and all its parts, and then a nested hinge under that which only affects the locking wheel, which weve defined as being able to rotate 360 degrees in both directions.

Thus the first hinge (safe$open door) contains an axis and the Door Group, while the second hinge (safe$turn wheel) contains its own axis and the object locking wheel. The other two mesh objects, tumbler and door are part of the door group but not the (safe$turn wheel) hinge group.

Multiple Hinges that Function Together (aka Multi-Hinges)

In certain cases, to get the motion you want, a several hinges need to function together, such as an accordion style assembly, or something that curls around.

For example, if you had a platform that rose up in a Z shape, or a series of blocks that closed into a circle but could unroll, you would use this multi-hinge function that ties multiple hinges together so that as you change one value in the imported object, all multi-hinges are affected equally.

The way you define several hinges to function as one multihinge is to simply give them the same hinge name but add a $# to end of the hinge name, where # is an incrementing number.

Thus, to create our unrolling octogon we first model the octogon with eight separate sides, and then put in a hinge at the joint of each side that should unroll. You need to remember to nest the hinges so that the first hinge will affect all seven of the sides, the next one will affect the following six sides and so on.

See the hierarchy on the right for an example.

Finally, you need to name all the hinges with the same name except for the final number, thus our unrolling octogons hinges are named 

ff3d_hinge_name(octogon$unroll$1) through ff3d_hinge_name(octogon$unroll$7).

Once this is imported into FrameForge, you will have an object that only has a single octogon:unroll hinge, and when you manipulate it, all of your defined multi-hinges will be affected equally as shown on the image to the left.

NOTE: If you need them NOT to be affected equally, such as one hinge moving twice as far for any given movement than another hinge, simply double-up on the hinge that you want to move twice as far so it actually has two identical hinges and that will get you the behavior that you want.


Like a hinge, a slider consists of two parts, the stationary part and the moving part but instead of the moving part rotating around the hinge axis, it slides in the direction the axis is pointing up to the length of the axis.

Lets go back to our example safe and lets add a sliding drawer inside it.

After we've added our drawer object, we need to add an axis object which points in the direction we want the drawer to slide and is as long as the distance the drawer should be able to slide.


In order to tell FrameForge what to name this slider and what parts it affects, we have to create a new Slider Group which is a group named ff3d_slider_name followed by a group name, then a dollar sign and the slider name.

hus, for our example safe, we will name the slider group for this drawer ff3d_slider_name (safe$slide drawer) and like the hinge group, it must contain exactly two objects.

One of them must be our axis named ff3d_axis (and since the length of the slider is defined by the length of the axis, we do NOT define a minimum nor maximum range within its name) and either a single object or a group containing all the objects to be affected by this slider.

Switch Cases

A switch case allows you to let the end user choose among part options. For example, our safe might have the options of a tumbler dial or a keypad. To create this switch case youd model both parts as individual meshes (or groups of meshes including, if desired, hinges or sliders) and put then put them within a switch group.

All switch cases start with a group that must be named ff3d_switch_name_<switch category> where <switch category> is an appropriate category for the switch. In the case of our safe, this line might read ff3d_switch_name_combination_style.

Inside of this switch group must be at least two case groups, which in turn can contain meshes, other groups, hinges and/or sliders as desired. They must each have a short name that defines the case (such as combination dial and keypad, in the case of our safe) though they dont have to follow any specific syntax.

The first case is the one which will be initially active when the object is first loaded and if you want to define a case where there is no meshfor example if a part is optional and you want to give the end user the option of completely removing it then you need to create a group, name it appropriately, then you must put in a placeholder object so that it is exported correctly.

This placeholder object must be named ff3d_placeholder and it can be any mesh because, like the axis object, it will automatically be removed during the import process.


If you have the Pro or Stereo Version of FrameForge, you can also build custom cameras to exactly match the size and shape of specific cameras, if for the stereo version, you can build stereo rigs which can function exactly like any specific stereo rig.

Creating a Camera

Like anything else, you first need to model the camera to scale. We recommend that you do not put in too many extraneous details as it will never show up on your final previs and the more complicated the camera object is, the more resources and rendering time it can take up.

Since you have your camera, you will need to define where in the camera the film/CCD Aperture is located. You do this with a special Camera Aperture Object located in the Object Creation Folder (only in Pro/Stereo Versions).

This object is named Camera Aperture and is available in several formats. Import the appropriate one into your model and you will see a right triangle that looks like the following (though without the text labels and yellow circle, of course):

There are a couple things you need to be aware of:

1) The point which describes the right angleshown circled in yellow in the image to the right defines the exact center of the aperture, and it is facing in the direction of the longest side of the right triangle (shown here with the label Direction of Light).

2)Because the actual film/CCD size is defined by the Film/Frame Size selected globally in the program, the size of this Camera Aperture Object has no relevance on the size of the ultimate aperture so you can make it as large or small as needed to easily manipulate it.

3) The Import function uses the differences between the lengths of the sides to identify its orientation, so it is very important that you maintain its aspect ratio if you size or scale it.

4) This camera Aperture object MUST be named as ff3d_camera_<CamName> where you will replace <CamName> with the name you want this camera to have.

To add this Camera Aperture to your model, we generally recommend that you go into a wireframe mode where all objects are transparent except for their edges, so you can better see where the Aperture Object is within the body fo the camera.

In the example to the right we placed the camera aperture (shown as the yellow triangle) just behind the lens, with the longer right angle side centered within the lens, and the shorter right angle side pointing up at the plane where the film or CCD is located.

We then changed the Aperture Objects name to ff3d_camera_Old_Fashioned Camera so that it will be named Old Fashioned Camera once weve imported it into FrameForge.

At this point, we could simply export it as VRML and import it as we would any other object, but since most cameras are attached to a head of some kind, you can also define the head attachment pointso FrameForge can know which heads this can work with, and where to attach it to the appropriate heads.

You define this attachment point with another special object you will find in the Object Creation Folder, the Camera Mounting (Camera) object. Once you import this, you will see that it too is a right triangle with one long side though it is labeled ff3d_tab_C.

Like the Camera Object, the size of this triangle does not matter, what is important is that the point which describes the right triangle is in the center of the attachment point, the long side is pointing towards the front of the camera and the short side is pointing to the right of the camera as shown by the red triangle in the image below.

Also like the Camera Object, you need to add the cameras name after ff3d_tab_C so that when FrameForge asks if you want to attach this camera to a head, it has the appropriate name to ask you.

NOTE: For all attachment points, FrameForge uses a Tab/Slot terminology so that tab_A attaches to slot_A, tab_B attaches to slot_B and so on. HOWEVER, even though this is labeled a tab it is NOT oriented perpendicular to the ground but is parallel as shown in the image above. Tab_C/Slot_C are the names for the standard Camera/Head attachment points, so if you are building a specialized camera that attaches to a specialized head, you can rename it to anything after tab_e and then build your specialized head and use the corresponding Camera Mounting (Head) object which gets oriented and named exactly the same way as the tab object, except it is ff3d_slot_c_<Head Name>.

Camera Support Equipment (dollies, heads, etc.)

If you have the Pro or Stereo Version of FrameForge, you can also make custom camera support equipment, such as dollies, heads and the like. You build and then hinge them as you would hinge anything else and often the Multi-Hinge Functionality described earlier in this document can be very useful and then add appropriate tabs and slots depending on how you would like the program to snap the equipment together.

NOTE: The standard camera mount is ff3d_tab_c_<CamName>, and the standard corresponding head mount is ff3d_slot_c_<HeadName> while the standard Mitchell Mount is ff3d_tab_b/ff3d_slot_b.

In addition to the hinges, sliders and tab/slots, all camera equipment needs to be scripted so FrameForge knows how to convert standard camera movements such as pan, crane, tilt into the appropriate motion using your newly created support equipment.

This is done via a subset of the .lua scripting language, and you need to create a lua script with the same name a the piece of camera support equipment with some or all of the following functions as appropriate

  • function CraneCamera( deltaElevation, cameraName )
  • function PanCamera( deltaAngle, cameraName )
  • function TiltCamera( deltaAngle, cameraName )
  • function RollCamera( deltaAngle, cameraName )
  • function ZeroCameraRoll(deltaAngle, cameraName )
  • function GetCameraRollRange(inWhichValue, cameraName)
  • function ResetSwingCamera( swingDelta, cameraName)
  • function SwingCamera( swingDelta, cameraName )

The easiest way to learn how to create a custom lua script is to look at the existing ones found in the camera equipment folder if you go to Tools-> Manage Support Folders->Camera Equpment

Stereo Rigs

To create a Custom Stereo Rig, you of course will need the Stereo Version of FrameForge Previz Studio, but otherwise it is rather straightforward.

1)       Build the model of your rig with the following considerations:

  All moving parts MUST be separate objects within the model Both cameras should be modeled within the rig

  The rig should be modeled at its zero position with the smallest interaxial it is capable of

  Minimize extraneous details so as to ensure that it is an efficient model

2)       Add all necessary sliders (and/or hinges), making sure that you have one hinge (for the convergence) and one slider (for the interaxial), named exactly as follows, though you can use the Multi-Hinge functionality if needed.

ff3d_hinge_name(stereo camera$convergence)
ff3d_slider_name(stereo camera$interaxial)

NOTE: (a) If both cameras toe-in and/or slide during interaxial changes, then you should use the Multi- Hinge Functionality described earlier in this document; (b) even if this rig is always used as a parallel rig, it MUST have the stereo camera$convergence hinge as the program uses that to store the rigs active HIT, though you can put a ff3d_placeholder object (described earlier in this document) within the hinge if desired.

3) Add in a SINGLE Camera Aperture Object to whichever of the two cameras is fixed within the rig and make sure that you name this camera aperture ff3d_camera_Stereo_Camera_<custom name> because that is what tells the program that this is a stereo rig versus a single camera.

NOTE: If both cameras slide during interaxial changes, then place the camera aperture exactly between the two cameras on a side-by-side rig, or the horizontal camera in a mirror rig (which should be at a zeroed, centered position).

Still need help? Contact Us Contact Us