Unreal Tournament 2004 Level Design -
xProcMesh Actor
Actor Classes - Actor - *xProcMesh (fluid type)
The xProcMesh provides Procedural Meshes that support
fluid vertex animation and real-time deformation.
This document covers only the MT_WATER fluid type of xProcMesh.
Table of Contents
- Adding the Actor to your Map
- Usage and Notes
- Creating banners and flags: xProcMesh vs Vertex-Animated Meshes
- Creating banners and flags with one fixed attachment side
- Creating water: xProcMesh vs FluidSurfaceInfo
- Creating the xProcMesh mesh
- Stock UT2004 xProcMesh banner and flag resources
- The DM-DG-xProcMesh demo map
- xProcMesh Actor Properties
- Example preset for vertical banners
- Example preset for standard horizontal water fluid surfaces
Adding the Actor to your Map
Select the *xProcMesh actor class in the Actor Classes browser, go to your map [T]op view
or Dynamic Light view and right-click at the desired map location, and choose "Add
xProcMesh here" from the popup menu.
Make sure that the editor's grid settings are at least 16 or smaller, otherwise the actor
may not place in the map or it may place in an odd location.
Specifying the Mesh
For animated banners and water, choose the StaticMesh that is to be used for the animated
mesh and assign it to the xProcMesh's Display.StaticMesh property.
Note: the Material assigned to the StaticMesh in the Static Mesh Browser window has no
effect on what is actually displayed for the xProcMesh. I normally assign the base
texture that the final xProcMesh will use to the Material property, just so that I know
which StaticMesh I am choosing in the browser, especially if there is a variety of the
StaticMeshes that I will be using in the map. This can be preferable to leaving the
default "bubble" texture on the StaticMesh, as it makes the StaticMesh in the
browser a bit more recognizable.
In most cases the xProcMesh will be one-sided and black at this time, we'll now fix that
by assigning the texture material and setting the lighting.
Specifying the Material
Choose the desired material for the xProcMesh and assign it to the Display.Skins[0] slot.
In order to use Skins, you must first click on the Add button to add a slot, then set the
material with the Use button.
The material will usually be a Shader or FinalBlend depending on the xProcMesh use.
For Banners, in many cases a base texture is used with a Combiner to overlay a logo on the
banner, then a Shader is used to support a Specular TexEnvMap to give the banner a better
shiny cloth look and a more noticeable animation as the cloth folds move.
For Water, in many cases a base texture is used with a TexPanner to give the water some
flowing animation, then a Shader is used to support a Specular TexEnvMap with the
reflection of the surrounding environment, and finally a FinalBlend is often used with a
FrameBufferBlending of FB_AlphaBlend and ZTest = True in order to facilitate proper
z-buffer drawing of any objects that are below the water surface.
The xProcMesh is probably still black or very dark.
Setting the Lighting
The xProcMesh actor does not use the standard map lighting to illuminate itself, neither
does its Display.bUnlit property have any effect.
To light an xProcMesh you must use either a Specular or SelfIllumination Shader Material,
or set the xProcMesh Display.AmbientGlow property to a value other than 0.
For Banners, a good AmbientGlow value range to use is usually somewhere between 24 and 64
depending on the surrounding map lighting.
For Water, the TexEnvMap in the Shader material is often enough to illuminate the
xProcMesh appropriately, you usually do not require additional lighting from the
Display.AmbientGlow property.
Note that by default the xProcMesh does not cast shadows. If you are using it for a
Banner and you wish to have it cast shadows onto the surrounding building and environment,
be sure to set the Display.bShadowCast property to True.
If you are also using the Advanced.bSuperHighDetail = True property to have the banner
displayed only for those systems running at maximum world detail, be sure not to cast
shadows with the banner, otherwise those people playing the map with lower world detail
settings will see the shadow with no banner to cast it.
Setting the Animation
The actual values used in the xProcMesh's xProcMesh.* properties will vary with the style
of xProcMesh you are creating.
See the Actor Properties and Example Presets at the end of this tutorial.
Notes
Once placed and when all of the desired properties are set, it is a good idea to lock the
xProcMesh actor so that it cannot be accidentally moved. This is accomplished by
setting the Advanced.bLockLocation property to True.
The xProcMesh fluid animation effect can be previewed in the 3D viewport using Realtime
Preview.
Usage and Notes
The usual uses for the xProcMesh are for custom-shaped fluid surfaces such as twisting
rivers or waterfalls, or for waving banners and flags.
On "startup", the entire xProcMesh may move along its equivalent-Z-axis until
the noise generation system that animates the vertices stabilizes.
If you modify the noise properties to a set of values that cause odd noise generation, the
entire mesh may move a substantial distance along its Z vector away from the xProcMesh
actor.
Creating banners and flags: xProcMesh vs Vertex-Animated Meshes
Vertex-animation will usually be more useful for meshes that require a non-water-fluid
style of animation, such as flags and other moving objects. See the flapping box
straps in the UT2004 AS-Convoy map as another example of where vertex-animated meshes are
usefull.
Many maps utilize the xProcMesh to provide custom hanging vertical banners and flags,
however, banners and flags are technically a wind style fluid-dynamic as opposed to a
water style fluid-dynamic as provided by the xProcMesh, so the visual effect is not
completely natural for this use.
The standard CTF flags and Team Banners actors within UT2004 are actually vertex-animated
meshes and not xProcMeshes. This allows them to have a more natural wind
fluid-dynamic look.
For your own custom banners, it will probably be much easier to use the xProcMesh than to
learn how to create vertex-animations. For those who would like additional
information on vertex-animation, see Epic's Unreal Developer Network topic VertexAnimation.
The current common UT2004 vertex-animated decoration meshes are:
- Actor.Decoration.*DECO_ConvoyFlag (massive horizontal banner)
- Actor.Decoration.*uTeamBanner.*banner_blue (hanging torn blue vertical banner)
- Actor.Decoration.*uTeamBanner.*banner_red (hanging torn red vertical banner)
- Actor.Decoration.*xTeamBanner (waving flag style banner on a pole)
Note that you will not see vertex-animated decorations move in the UnrealEd realtime
preview. They insert into the editor as yellow color meshes.
Creating banners and flags with one fixed attachment side
Most banners or flags have one fixed side where the cloth attaches to the hanger or post.
Unfortunately, the xProcMesh property of bRigidEdges only allows you to set all edge
vertices to rigid. You cannot specify just one side. This usually works well
for water surfaces, but is unrealistic for banners and flags.
Real banners and flags also tend to have less motion near the attached side and greater
motion where the cloth hangs free.
This effect can be achieved using one of two different methods.
1. Using a Masked Skin Texture with bRigidEdges.
- Create a masked texture where one side aligns with the edge of the mesh, and the other
three sides are at least one set of faces in.
- Create a standard banner xProcMesh.
- Set the xProcMesh.bRigidEdges to True. This makes all edge vertices fixed.
- When the xProcMesh animates, one side of the texture will be rigid and the other three
will appear to move because their edge faces will be transparent.
2. Using a UVM_Skin gradient. See BR-TwinTombs.ut2
- Create the mesh, texture and xProcMesh.
- Create a solid or grayscale gradient texture and assign it to Display.UV2Texture and set
Display.UV2Mode to UVM_Skin.
This special texture will apply dampening to the xProcMesh animation depth depending on
the value of the skin texture pixels.
Any areas of the xProcMesh where the skin texture is pure black (0) will be rigid.
Gradient values from just above black up to pure white (255) will allow animation motion
depending on their gradient value, where black is no motion up to white which is full
motion.
- You must do a Build All after assigning this skin texture or you will not see the
change, and most times you will find that the xProcMesh will not "load" the skin
texture, requiring you to exit and re-run UnrealEd to see the change.
- You can use a texture that is pure white with a solid black strip on one end, however,
by using a gradient texture the animation depth increases by the gray value from black to
white.
- See the texture dom-goose.Lost-banners.bannergrad for an example.
- This skin texture should preferably be large, such as 1024x1024, and a square aspect
ratio. A P8, DXT1, DXT3 or DXT5 will work. The value in the main texture is what is used,
any alpha channel information is ignored.
The skin texture is applied effectively on a fixed scale, so a 256x256 skin texture will
only affect a small portion of the top of a tall vertical banner.
- You do not need to generate MipMaps for this skin texture, which will save some texture
space.
- This same skin texture technique could be used with a water surface xProcMesh, to
achieve varying degrees of motion where ever you preferred, but creation of the gradient
texture would be some work.
Creating water: xProcMesh vs FluidSurfaceInfo
UT2004 (UnrealEngine 2.5) also includes a FluidSurfaceInfo actor, which for standard
pond/river/lake/ocean construction is usually a better alternative to using an xProcMesh.
The FluidSurfaceInfo is essentially a version of a Procedural Mesh that is designed and
optimized for creating water surfaces, and includes additional features specifically for
that purpose. It also automatically generates its mesh grid based on the specified
properties.
FluidSurfaceInfos have a superior fluid animation to xProcMeshes, along with additional
properties for managing this.
The xProcMesh on the other hand, has a smaller number of fluid features, but includes the
ability to create real-time deformable meshes.
The xProcMesh does have the ability to outperform the FluidSurfaceInfo in the area of
shape optimization.
FluidSurfaceInfos support automatic vertex clamping to Terrain, BSP, Blocking Volumes and
StaticMeshes with Simplified Collision Models.
The vertex clamping method for xProcMeshes is considerably more limited, and consists of
creating a 1024x1024 grayscale bitmap where values closer to black are clamped, while
values closer to white are not.
There is no LOD (Level of Detail) capabilities for xProcMeshes or FluidSurfaceInfos.
To the level designer, this means that the entire mesh renders if any portion of it is
visible within the frustum, even if the player is a considerable distance away from the
actor.
Because of this, xProcMeshes should be used sparingly, and their triangle count should be
optimized to be only that required for the visual purpose.
Since FluidSurfaceInfos also do not support LOD, an xProcMesh used in place of a
FluidSurfaceInfo in some cases may result in a noticeable in-game speed improvement.
This is noticed especially in cases such as winding rivers, which would require a large
square or rectangular FluidSurfaceInfo that has a large percentage of its triangles not
visible (ie. they are hidden under the terrain).
An xProcMesh in this specific case would only require the appropriate number of triangles
to cover the river surface. There would be no "wasted" triangles hidden
under the terrain that also had to be rendered.
An xProcMesh can also have a non-1:1 UV texture mapping, allowing for winding rivers whose
texture follows the curve of the mesh. This is also useful for waterfalls, where the
"texture animation" of water flow over the falls is much faster than that of the
horizontal water areas.
For water use of xProcMeshes you will also require a WaterVolume in order to obtain the
water physics and splash effects and sounds.
This table shows a brief comparison of the xProcMesh and FluidSurfaceInfo.
| Comparison |
xProcMesh |
FluidSurfaceInfo |
| Freeform shapes (bend) |
Yes |
No (fixed square or rectangle) |
| Irregular shapes (oval) |
Yes |
No (fixed square or rectangle) |
| Internal shape holes (donut) |
Yes |
No (visual only with opacity) |
| Freeform UV mapping |
Yes |
No (fixed 1:1 over surface) |
| LOD (Level of Detail) |
No |
No |
| Optimized faces (hide non-visible) |
Yes (with proper mesh design) |
No (entire grid renders) |
| Edge clamping |
Optional (set by property) |
Fixed (always on) |
| Vertex clamping |
Yes (limited ability, UVM_Skin) |
Yes (Terrain, BSP, BlkVol, SMesh) |
| Freeform triangle mesh layout |
Yes |
No (fixed hex or square) |
| Maximum size |
None (within reason) |
Yes (256x256 vertices) |
| Player/Projectile splash |
No (not directly) |
Yes |
| Fluid visual quality |
Good |
Better |
| Fluid adjustment properties |
Good |
Better |
| Fluid pixel shader |
No |
No |
Creating the xProcMesh mesh
The main obstacle in creating meshes for xProcMesh use, is finding the correct balance
between the number of triangles, and the quality of the visual animation.
If you use too many triangles, it will impact the game's framerate, and your map will play
slow when the xProcMeshes are being rendered.
If you use too few triangles, the fluid effect will be choppy and jagged.
Fluid Surfaces
Water is normally created from a grid of square triangle pairs (quads).
A good rule of thumb for the size spacing of triangles used for xProcMesh fluids in rivers
or lakes, is around 64 Unreal Units. If the xProcMesh fluid is a small custom shape
such as a water well, then you can go as small as 16 Unreal Units. For large ocean
size bodies of water, triangle size should be 128 to 256 Unreal Units.
A simple method of determining what the triangle size should be for your xProcMesh, is to
first place a FluidSurfaceInfo into your map, adjust its sizing until you get the desired
visual look, then take note of the FluidSurfaceInfo's property for FluidGridSpacing and
create your xProcMesh accordingly.
There are numerous methods that you can use in order to create your custom xProcMesh fluid
shape.
One method that can be used is to place a FluidSurfaceInfo into the map, and from the
[T]op 2D viewport, take a screen capture and paste that into paint software. Edit
this and use it as a background in your 3D software for a shape reference.
Or if you are using a terrain based map, you could paint an Alphamap texture layer onto
the terrain with a high contrast texture, then in the [T]op 2D viewport, take a screen
capture of the terrain and use the texture as a shape outline.
Then start off with a large square Quad Patch Grid of the proper triangle size, and select
and delete triangles that fall outside of the desired fluid area.
For my custom terrain based maps, I use special software that I have written that allows
me to convert what is effectively an Unreal terrain Alphamap texture layer into a .obj or
.stl file that I can import directly into 3DS Max.
Vertical Hanging Banners
Most level designers will simply copy the existing vertical hanging banner meshes from the
stock UT2004 maps. But if you require a special custom shape, it is actually quite
easy to create your own.
Vertical hanging banners usually animate better if they are created from a grid of
elongated triangles. This causes the "ripples and waves" of the xProcMesh
fluid animation to look more like long folds in cloth.
A good rule of thumb is to create the triangles at a 1:4 aspect ratio.
So if the triangle is 8 Unreal Units wide, make it 32 Unreal Units long.
In 3DS Max you can start off with a Plane of the desired length and width or you can use a
Quad Patch Grid, copy and position it so that you have two or three, attach and weld them
together, then delete any unnecessary triangles on the sides or bottom.
If you position your mesh so that it is located with its top-center at the 0:0:0 origin,
it will insert better into UnrealEd and line up correctly with the xProcMesh Actor.
Once you have the basic patch grid mesh, simply delete unneccesary triangles and adjust
the location of triangle vertices until the desired shape is obtained.
The method that I use to create custom shapes such as the curved angle edge on the above
mesh, is to place a few Spline objects as reference lines, then adjust the mesh vertices
on a grid scale of 1 so that they are as close as possible to the spline reference lines.
Once completed, delete the spline reference lines, apply a 1:1 UV Map, collapse the Stack,
then export the mesh as an .ase file.
Import the final fluid or banner mesh into UnrealEd.
Set all collision properties to False.
You can assign a texture in the StaticMesh Browser, but it will not be used in-game.
Insert an xProcMesh actor, and assign your StaticMesh to its Display.StaticMesh property.
Stock UT2004 xProcMesh banner and flag resources
Stock UT2004 Maps with xProcMeshes:
BR-TwinTombs (Banners)
CTF-LostFaith (Banners and Water)
Stock Vertical Banner Materials:
ArboreaHardwareBrush.Miscellaneous.BannerBlue (Texture)
ArboreaHardwareBrush.Miscellaneous.BannerGreen (Texture)
ArboreaHardwareBrush.Miscellaneous.BannerOrange (Texture)
ArboreaHardwareBrush.Miscellaneous.BannerPurple (Texture)
ArboreaHardwareBrush.Miscellaneous.BannerSymbol1 (Texture)
ArboreaHardwareBrush.Miscellaneous.BannerSymbol2 (Texture)
ArboreaHardwareBrush.Miscellaneous.BannerSymbol3 (Texture)
ArboreaHardwareBrush.Miscellaneous.BannerSymbol4 (Texture)
dom-goose.Lost-banners.BannerRed (Texture)
dom-goose.Lost-banners.Bluebanner-Lost (Shader)
dom-goose.Lost-banners.Red-banner-shader (Shader)
MikeDemoLevel.BannerBlue (Texture)
MikeDemoLevel.BannerGreen (Texture)
MikeDemoLevel.BannerOrange (Texture)
MikeDemoLevel.BannerPurple (Texture)
MikeDemoLevel.BannerSymbol1 (Texture)
MikeDemoLevel.BannerSymbol2 (Texture)
MikeDemoLevel.BannerSymbol3 (Texture)
MikeDemoLevel.BannerSymbol4 (Texture)
wm_textures.wm_BlueBanner (Shader)
wm_textures.wm_RedBanner (Shader)
Stock Flag Materials:
XGameShaders.BlueFlag (Texture)
XGameShaders.RedFlag (Texture)
XGameShaders2004.CTFShaders.BlueFlagShader (Shader)
XGameShaders2004.CTFShaders.BlueFlagShader_F (FinalBlend)
XGameShaders2004.CTFShaders.RedFlagShader (Shader)
XGameShaders2004.CTFShaders.RedFlagShader_F (FinalBlend)
Stock Banner/Flag TexEnvMap Materials:
CubeMaps.Alleria.AlleriaGenTexEnv (TexEnvMap) good for blue banners
CubeMaps.Citadel.citadelTexEnv (TexEnvMap) good for red banners
CubeMaps.Cubes.Osiris-texenv (TexEnvMap) good for green banners
dom-goose.Lost-banners.Banner-texenv (TexEnvMap) good for any color banner
Stock Banner/Flag Clamping Gradient Materials:
dom-goose.Lost-banners.bannergrad (Texture)
The DM-DG-xProcMesh demo map
This demo map shows examples of an xProcMesh River, Banners and a flag.
Note that the banners in the background are from stock UT2004 maps and the flags in the
background are the stock UT2004 Vertex Animated Meshes.
Note that the example banners in this map are very simplistic rectangular shaped meshes.
In addition to a demo map showing xProcMeshes in action, the zip file also contains a
number of other useful assets such as various xProcMesh Clamping Gradient materials.
The xProcMesh versus FluidSurfaceInfo river:
The equivalent FluidSurfaceInfo to create the river with the identical triangle sizing of
64x64 quads would be a FluidGridSpacing of 64 and FluidXSize of 76 and FluidYSize of 128,
for a total of ((75*127)*2) = 19050 triangles.
Compare this to the xProcMesh with only 2311 triangles.
That is 8.24 times as many triangles if a FluidSurfaceInfo was used.
At 1/12th the number of triangles, a considerable speed improvement will be realized with
the xProcMesh. However, this is at a sacrifice in player/projectile splash effects.
Please be sure to credit DGUnreal or David 'DGUnreal' Green in your map's readme file if
you use any of the custom textures or staticmeshes from this map in your own.
xProcMesh Actor Properties
Property comments here are relating to the MT_Water type xProcMesh.
Unfortunately, many of the actor's property values must be specified according to the
specific staticmesh design that is used. The number and layout of the mesh triangles
will determine what values will give the best visual look. The ranges given here are
usually good under normal design circumstances.
When you modify any of the xProcMesh settings for Noise etc., it may take up to five
seconds before you see the updated results on-screen, as the vertex array is modified by
the procedural noise.
Also note that the animation in-game may differ than what the editor real-time preview
shows. This can be frustrating and may require a few times of launching the map to
check the animation. In most cases, the in-game animation is slightly faster and has
less depth of motion, so adjust the properties accordingly.
Since this actor is not documented on UDN or even the Epic Developer Forums, those
properties that are unknown or unsure of at this time are preceeded by "??".
Those properties preceeded by "??" are educated guesses as to what is occurring
in the xProcMesh through observation (if any UE licensee has the C++ for the UE2.5
xProcMesh feel free to contact me, I am under NDA).
When I get some additional free time, I will explore the apparently non-working areas of
the xProcMesh with some scripts, and update this tutorial.
The comments for these properties are as related to a horizontal water fluid style
xProcMesh. For other types such as banners, re-orient the xyz axis accordingly.
| Collision |
| bUseCylinderCollision |
Use simplified cylinder
collision.
Default = True
This property should always be changed to False.
Otherwise a small cylindrical collision is created around the actor icon that blocks
projectiles, etc. |
| CollisionHeight |
Simplified cylinder
collision height.
Default = 80.0
This should be changed to 0.0. |
| CollisionRadius |
Simplified cylinder
collision radius.
Default = 80.0
This should be changed to 0.0. |
| Display |
| AmbientGlow |
Specifies the amount of
ambient light on the mesh.
Default = 0
A value between 64 and 128 is usually sufficient to light the mesh.
You must use this property with xProcMeshes as they do not light the same as other fixed
world objects.
If you leave this at the default value of 0, the xProcMesh will be black.
Alternately, you could use a texture material supporting self-illumination.
xProcMeshes do not support any amount of dynamic lighting, so they will always look quite
flat (no shadows).
You can improve this flat look by using a Shader with a TexEnvMap, since a TexEnvMap
changes visually with the mesh face's surface normal.
If the chosen TexEnvMap is of a similar color to the xProcMesh's texture, the apparent
visual contrast and motion will look considerably better.
I also always use Detail textures whenever possible.
See the blue and red vertical banners in the xProcMesh demo map for an example. |
| bShadowCast |
Specifies whether the mesh
casts shadows onto surrounding world objects.
Default = False
The default for this property is False, however, if you wish your xProcMesh to cast
shadows, such as from a banner, set this to True.
Note that the shadow will be created during the UnrealEd build, so it will be relevant for
the current animation noise frame of the xProcMesh and will not animate its shadow. |
| DrawType |
Specifies the rendering
engine setup for drawing this type of object.
Default = DT_Particle
The default for this property is DT_Particle which is what the actor's Texture icon is (an
Emitter icon), however, if you are encountering Z-draw errors such as an Emitter fire not
properly drawing over the xProcMesh, then set this to DT_Mesh or set
Display.bDeferRendering to False. |
| Skins.[0] |
Specifies the displayed
xProcMesh texture.
Default = None
You must use this Skin slot. You cannot simply assign the texture to the StaticMesh
in the StaticMesh Browser properties, or it won't be properly visible in game. |
| StaticMesh |
Specifies the xProcMesh
staticmesh.
Default = None
This must be a properly constructed triangulated mesh surface.
There must be sufficient faces to achieve the desired water or deformation effect.
If there are too few faces, the mesh animation will be jumpy and vertices will pop.
If there are too many faces, it will impact the game framerate.
If you are updating the source staticmesh in the StaticMesh Browser, you may have to Clear
then re-assign (Use) the Display.StaticMesh property or the currently displayed xProcMesh
may be a wild bunch of faces scattered in the editor. |
| Force |
| bForceAffected |
?? Whether the xProcMesh
is affected by forces (Karma). |
| xProcMesh |
| BigHitEffect |
?? The effect to play for
big hits.
Default = None
Choose the effect from the dropdown list.
BigHit would be defined as Damage >= BigMomentumThreshold or Touch >=
BigTouchThreshold.
This apparently does not function. |
| BigMomentumThreshold |
?? TakeDamage (projectile
hit) threshold to play BigHitEffect.
Default = 0.0
This apparently does not function. |
| BigTouchThreshold |
?? Touch (player touch)
threshold to play BigHitEffect.
Default = 0.0
This apparently does not function. |
| bRigidEdges |
Specifies whether the
mesh's edge vertices are fixed (non-moving) or whether they also animate/deform.
Default = False
True = fixed edges, False = animating/deformable edges.
This is similar to the FluidSurfaceInfo whose edge vertices are always fixed.
For standard fluid surface use, this should be set to True. |
| CheckCollision |
?? Specifies whether to
check for TakeDamage or Touch collision.
Default = True
True = Yes, False = No.
This apparently does not function. |
| Dampening |
Specifies how quickly the
animated mesh vertices return back to their normal position.
Default = 0.5
The range is 0.0 to 1.0.
If you want high waves that die away quickly, increase Dampening up between 0.5 to 1.0.
If this value is 0.0, the water slowly becomes increasingly active and wavey as if it were
being constantly disturbed. |
| DampeningRange.Min,Max |
?? Specifies the number of
surrounding vertices that the dampening affects.
Default: Min= -4.0 Max= 4.0
This has no visual affect that I can see. |
| ForceAttenuation |
?? Specifies the amount to
attenuate the [Karma] force hitting the mesh.
Default = 1.0
Force.bForceAffected must be True? |
| ForceClamp.Min,Max |
?? Specifies the amount to
clamp the force that is hitting the mesh between the Min and Max.
Default: Min= -20.0 Max= 20.0 |
| HitEffect |
The effect to play for
regular hits (versus Big Hits).
Default = None
Choose the effect from the dropdown list.
This apparently does not function. |
| InfluenceRadius |
?? Specifies the Shoot,
Touch, or Force radius of vertices influenced.
Default = 0.0
This apparently does not function. |
| MovementClamp.Min,Max |
Specifies the wave Z
altitude range to clamp the vertex motion to.
Default: Min= -50.0 Max= 50.0
The mesh vertex animation movement will never exceed these Min/Max negative/positive
values.
This should be a pair of equal negative/positive values. You can use a set such as
-10.0 and 80.0, which will cause the waves to be clamped shorter on the lower side of the
mesh.
If you use a positive range only, the vertex Z altitude movement is restricted to the
upper side of the mesh.
If you use a negative range only, the vertex Z altitude movement is restricted to the
lower side of the mesh.
The smaller the range, the smaller the water wave or deformation as they are clamped.
If you are adjusting the xProcMesh.NoiseForce range to a greater value and it does not
seem to be changing the animation, be sure that you are not clamping the vertices too
tight with the MovementClamp properties. |
| Noise |
Specifies the overall
Noise amplitude.
Default = 0.1
The usable range is 0.001 through 0.5.
Values greater than 0.5 may become wildly wavey and tend to push the entire mesh in the -Z
direction. At times you may encounter values greater than 0.1 may stop the vertex
motion animation depending on the mesh design and the other xProcMesh property values. |
| NoiseForce.Min,Max |
Specifies the strength of
the noise applied to the mesh vertices.
Default: Min= -1.0 Max= 1.0
This should be an equal pair of positive/negative values, eg: -2.5, 2.5.
The usable range is usually between 0.05 and 20.0 (negative and positive).
Values greater than 20.0 tend to make the water too wavey and choppy, as the mesh vertices
are pushed very far and fast by the noise.
If the xProcMesh.Noise value is large, this value should be small, and vice-versa. |
| NoiseTimer.Min,Max |
Specifies the noise timer
range.
Default: Min= 2.0 Max= 3.0
These two values work like noise generator random number seeds, providing a slightly
differing noise with each different set of values.
The usable range appears to be from 0.0,0.0 to anything...
The noise is visually more random if the two values are not equal or identical, eg: -3.0,
7.0. |
| ProcType |
The Procedural Mesh type:
MT_Deform or MT_Water.
Default = MT_Water
MT_Water provides a procedural vertex animation that simulates fluid motion.
MT_Deform provides a simple staticmesh that supports deformation through vertex
manipulation, such as dynamic terrain, metal sheets that indent when shot, etc. The
MT_Deform type requires additional scripting to manage the vertex deformation. |
| RestTension |
?? Surface tension between
vertices in rest state.
Default = 0.4
This changes the viscosity of the water.
Larger values tend to become more gelatinous as the entire mesh provides large undulating
waves like jello.
This value works in conjunction with xProcMesh.Tension.
See xProcMesh.Tension |
| ShootStrength |
Specifies the damage
amount required for a projectile to cause a HitEffect.
Default = 0.0
This apparently does not function. |
| Tension |
?? Surface tension between
vertices in animation motion.
Default = 0.4
This changes the viscosity of the water.
Large values such as 10.0+ increase the animation Z motion.
Small values such as 0.1 decrease the animation Z motion.
Usable range = 0.001 to 10.0. A value of 0 stops the animation. Values greater than
10 cause rapid sharp vertex animation.
See xProcMesh.RestTension |
| TouchStrength |
Specifies the touch amount
required for a player to cause a HitEffect.
Default = 0.0
This apparently does not function. |
Example preset for vertical banners
This xProcMesh preset assumes that the StaticMesh is a vertical grid of quads similar to
those found in the DemoMap, used for hanging vertical banners.
| BigHitEffect |
None |
Default |
| BigMomentumThreshold |
0.0 |
Default |
| BigTouchThreshold |
0.0 |
Default |
| bRigidEdges |
False |
Default |
| CheckCollision |
True |
Default |
| Dampening |
0.2 |
. |
| DampeningRange.Min,Max |
-4.0, 4.0 |
Default |
| ForceAttenuation |
1.0 |
Default |
| ForceClamp.Min,Max |
-20.0, 20.0 |
Default |
| HitEffect |
None |
Default |
| InfluenceRadius |
0.0 |
Default |
| MovementClamp.Min,Max |
-40.0, 40.0 |
Value can be up to -80.0,
80.0 |
| Noise |
0.05 |
. |
| NoiseForce.Min,Max |
-30.0, 30.0 |
. |
| NoiseTimer.Min,Max |
0.5, 0.2 |
Note that Min is larger
than Max |
| ProcType |
MT_Water |
Default |
| RestTension |
0.1 |
. |
| ShootStrength |
0.0 |
Default |
| Tension |
0.7 |
Can be as low as 0.5 |
| TouchStrength |
0.0 |
Default |
Example preset for standard horizontal water fluid surfaces
This xProcMesh preset assumes that the StaticMesh is a horizontal grid of quads similar to
those found in the DemoMap, used for ponds, rivers, lakes or oceans.
| BigHitEffect |
None |
Default |
| BigMomentumThreshold |
0.0 |
Default |
| BigTouchThreshold |
0.0 |
Default |
| bRigidEdges |
True |
Clamp the edge vertices
below the terrain |
| CheckCollision |
True |
Default |
| Dampening |
0.5 |
Default |
| DampeningRange.Min,Max |
-4.0, 4.0 |
Default |
| ForceAttenuation |
1.0 |
Default |
| ForceClamp.Min,Max |
-20.0, 20.0 |
Default |
| HitEffect |
None |
Default |
| InfluenceRadius |
0.0 |
Default |
| MovementClamp.Min,Max |
-50.0, 50.0 |
Default |
| Noise |
0.1 |
Default |
| NoiseForce.Min,Max |
-2.5, 2.5 |
Higher values equals
higher waves |
| NoiseTimer.Min,Max |
0.05, 0.05 |
. |
| ProcType |
MT_Water |
Default |
| RestTension |
8.0 |
Can be as low as 1.0 for
smoother waves |
| ShootStrength |
0.0 |
Default |
| Tension |
3.0. |
Can be as low as 0.5 for
smoother waves |
| TouchStrength |
0.0 |
Default |
|
