User Tools

Site Tools


General Terms

Billboarding is the concept of something always facing the camera or screen. Leaf cards and simple tree billboards in SpeedTree are examples of objects that billboard.

The application used to convert Modeler files (SPM) to run-time files for the SDK (SRT).

In addition to referring to large leaves (such as a palm frond), a frond can be a fake branch achieved using textures.

Leaf Card
Leaf cards are leaves that always billboard (face) the camera. This allows a SpeedTree to look very lush and full while having few leaf polygons. Historically, these were the only kinds of leaves used on SpeedTrees, but now there are leaf meshes as well.

Leaf Mesh
A leaf mesh is a small piece of geometry that is used in place of a leaf card. This is useful for fruit, vines, long stringy leaves, and anything else that cannot be modeled accurately with leaf cards.

Level of Detail
Level of detail refers to drawing lower quality objects the smaller they are or further they are away from the camera. SpeedTrees can drop down multiple levels of detail, all the way down to a single billboard.

See “Level of Detail”.

The application where SpeedTrees are created.

The SpeedTree® Software Development Kit, which houses the libraries and source code for loading trees, animating them for wind, performing LOD, batching for fast rendering, and actual render calls for specific platforms.

Tree Library
The sum total of all the trees, textures, meshes, etc. IDV can provide for use with the SpeedTree® applications/tools.

Modeling Terms

Alpha Scalar
Sometimes the alpha channel of an image is not entirely suitable for use on a SpeedTree, especially when alpha to coverage is used. An alpha scalar allows the alpha channel to be modified in the shader.

Ambient Occlusion
Ambient occlusion refers to precomputed ambient lighting information. Inner parts of the tree are “occluded” by other parts of the tree, which leaves the inner parts darkened. Ambient occlusion can greatly increase the realism of a tree.

An asset is an object that is used in the construction of a SpeedTree, such as a material, a mesh, a mask, etc.

A collection is a mesh asset that is created from other parts of the tree during tree computation. This asset can then be used as any other mesh, as part of the tree or on a mesh force.

Collision Object
Per-triangle collision can be expensive, so SpeedTrees support the inclusion of collision volumes (spheres and capsules). These can be queried through the SDK for rough collision instead of, or previous to, per-triangle collision detection.

Color Set
A color set houses all of the render state information for a material, which in contrast houses all the texture information. Color sets are separate assets from materials so the artist, if he so chooses, can manage draw calls in the SpeedTree® SDK. Two materials that use the same color set can be batched in the Compiler and SDK for faster drawing.

Many properties are guided by curves that further influence the random values used to compute a tree based on position on the parent (parent curves), down the length of a node (profile curves), through LOD levels (lod curves), etc.

A very complex tree can take a long time to compute and/or draw. Degradation allows an artist to work on a simpler version of the SpeedTree for the sake of speed and then switch easily to the full quality.

Displacement is a per-vertex translation based on noise or an image loaded into a displacement asset. It can be used to create a bumpy branch, for instance.

A force is an object that can deform, restrict, or otherwise influence the creation of part or all of a SpeedTree.

A generator is an object that creates nodes in a SpeedTree. Generators can be seen in the Generation bar in the SpeedTree® Modeler.

A mask is a restriction to the area where something can be created. It can restrict based on position, texcoords, or an image.

Mesh Force
A mesh force is a force that utilizes a mesh asset in some manner, such as a rock mesh colliding with a tree's roots.

A node is an actual object created in the tree, such as a single branch or a single leaf.

Node Edit
A node edit is a modification of some value on a single node that does not affect other nodes created from the same generator.

Normal Map
A normal map is a texture containing tangent-space normal information. Using normal maps and an appropriate shader, lighting can be performed per-pixel rather than just per-vertex, resulting in much higher quality lighting without an increase of geometry.

Every object (generator, node, force, etc) has a number of properties that can be adjusted on it. Properties can be numbers, choiceboxes, curves, etc., or some combination of these.

A SpeedTree is built around guided random values. Thus, a part or all of a tree can be “randomized” to create a new version of the same tree.

Static Mesh
In contrast to a SpeedTree, a static mesh does not have wind effects, smooth LOD, or camera-facing leaves. When exporting a SpeedTree to another modeling package, it becomes a static mesh.

Transmission is the light that shines through leaves on a tree, illuminating the dark side. The SpeedTree shaders can simulate light transmission.

World Building
World building is the construction of a scene, environment, or area. The SpeedTree® Modeler can facilitate world building through the use of zones, masks, and proxies. The worlds built can then be exported to other applications or used in the SpeedTree® SDK.

A zone is a mesh placed in a SpeedTree from which other things can be created, such as a wall with ivy growing over it. Zones are also used as a terrain mesh for world building.

Compiler/SDK Terms

Memory allocating inside the SDK can be routed through a custom allocator so the user of the SDK can keep track of memory usage.

Alpha Fizzle
Alpha fizzle is the term applied to the “fizzling” from one LOD to another based upon changing alpha testing values in unison with returning alpha noise from the pixel shader.

Alpha Testing
Alpha testing, also called alpha masking, is a way to mask out certain pixels from rendering based on alpha values of the object's pixels and the alpha test reference value. By putting uniform noise in the alpha channels of the diffuse texture, manipulation of the alpha test reference value can produce a fizzling effect from one LOD to the next.

Alpha To Coverage
Alpha to coverage, or A2C, is a technique use the alpha as a coverage mask in the multisample buffer. When multisampling is used, it allows for smoother edges on alpha tested geometry.

An atlas (previously known as a composite map) is a texture that combines all of the textures needed for a SpeedTree that do not need to be wrapped. Multiple textures from different materials are merged into one large texture that is used to minimize texture context switches during rendering. Branch textures cannot be included in the composite map because they wrap around the tree in multiple directions.

Base Tree
A base tree is an actual tree (SRT) loaded into the SDK. Instances then reference the original base tree.

Batching geometry together into fewer draw calls can dramatically improve rendering times. This is especially useful for SpeedTrees when scenes have many billboards. Hundreds or even thousands of billboards can be batched together for large, sweeping vistas of trees running at real-time.

The lowest LOD of a SpeedTree is a billboard, just a picture of the tree. There can either just be one, or many billboards rendered from multiple directions around the tree.

Billboard Map
The billboard map is similar to the composite map, but only contains billboards. Separate billboard maps are an option in case the composite map gets too large or if other optimizations work better with separate billboard maps.

The forest library splits the environment into evenly sized cells, or regions, to allow for fast culling.

Culling is the act of throwing out objects during rendering which aren't visible. Culling to the view frustum is the most often used form of culling.

Effect LOD
Effects per LOD can be configured in the SpeedTree® Compiler using the Effect LOD dialog. In the same way that SpeedTree allows for smooth geometrical LOD, effect lod is also smooth since the effects will fade off rather than pop/

Endianness refers to the byte ordering within a single 16-, or 32-bit value. Most machines use little endian, while some (PS3, Xbox 360, etc.) are big endian. Converting between these is sometimes necessary when loading binary data.

Fizzling is to drop out or bring in pixels randomly while switching LODs on a SpeedTree. It is caused by using alpha testing in concert with uniform noise returned from the pixel shader.

Grass in the SDK is a specialization of the same culling/batching/rendering system as used on trees that achieves better performance for small objects near the camera by doing away with things such as LOD and billboards.

Instancing is the concept of having one unique object that gets drawn in many places. SpeedTrees use instancing to avoid calculating wind effects and billboarding for every tree in a scene. Alternatively, instancing also refers to the rendering concept of “mesh instancing” where one mesh can be drawn multiple times with different properties in a single draw call.

The process of merging some or all of the reference application code into your own application or game.

Reference Application
The reference applications show how to get SpeedTree working in an application. The reference applications are highly optimized for performance with lots of trees in a scene rendered in high quality.

Render State
A render state describes the setup of a particular rendering call, comprising textures bound, shaders used, rendering states set, etc.

A program that runs on the graphics card. The SpeedTree SDK utilizes vertex and fragment/pixel shaders.

Shader Constant
A value uploaded to graphics card memory that can be accessed by a shader, used for things that don't change per vertex.

A combination of a vertex and pixel shader that work together to provide certain effects.

Wind LOD
Wind effects are the most computationally expensive part of the SpeedTree vertex shaders. Having them smoothly LOD out can improve render speed while maintaining quality wind motion close to the camera.

File Extensions

Mesh File Formats

  • FBX, OBJ, DAE, 3DS: Other file formats that can be imported/exported in various places in the SpeedTree tools.
  • SPM: SpeedTree Procedural Model, the files used by the SpeedTree® Modeler.
  • SRT: SpeedTree RunTime, the files written by the Compiler for use with the runtime SDK.
  • STM: SpeedTree Mesh, a mesh format used for mesh assets in the SpeedTree® Modeler that requires exporters for modeling packages. Is being superceded by better OBJ and FBX support.
  • XML: All mesh exporting, including SRT creation, saves out an intermediate raw file format in XML.

Image file formats

  • DDS: Direct Draw Surface, an image wrapper format that supports alpha channels and compressed textures in native graphics card formats.
  • GTF: Native image format on the PS3. It is basically a wrapper around DDS data.
  • GXT: Native image format on the PSP2 Vita. It is basically a wrapper around DDS data.
  • TGA: Targa image files, which support alpha channels and are very easy to write/parse. These are normally used for uncompressed images.
  • TIFF, PNG: Other suitable image file formats (that is, they support alpha channels) that can be imported/exported in various places in the SpeedTree tools.

Other File Formats

  • SCS: SpeedTree Compiler Settings, the settings file saved/loaded by the SpeedTree® Compiler.
  • SFC: SpeedTree Forest Configuration, a file containing all the settings for a scene to be loaded into the SDK's Reference Application. It is not necessary to use this file in your own applications, but it does give a way to edit and run forests with different settings quickly and easily.
  • SME: SpeedTree Mesh Exporter, the file describing a mesh exporter for use with the SpeedTree® applications.
  • STF: Older (<v6.0) forest file that can be written from the Modeler and read in the SDK.
  • SWA: New (v6.0+) ASCII world building / forest file that is written from the Modeler and read in the SDK.