Chapter 3: Node Reference--The Annotated VRML97 Reference Manual

ElevationGrid { eventIn MFFloat set_height exposedField SFNode color NULL exposedField SFNode normal NULL exposedField SFNode texCoord NULL field MFFloat height [] # (-

) field SFBool ccw TRUE field SFBool colorPerVertex TRUE field SFFloat creaseAngle 0 # [0,

] field SFBool normalPerVertex TRUE field SFBool solid TRUE field SFInt32 xDimension 0 # [0,

) field SFFloat xSpacing 1.0 # (0,

) field SFInt32 zDimension 0 # [0,

) field SFFloat zSpacing 1.0 # (0,

) }

The ElevationGrid node specifies a uniform rectangular grid of varying height in the Y=0 plane of the local coordinate system. The geometry is described by a scalar array of height values that specify the height of a surface above each point of the grid.

TIP: The ElevationGrid node is a good candidate for the floor or terrain of the scene since it provides better compression than an IndexedFaceSet and thus shorter download time. It is best to divide the scene into regions to allow the browser to perform rendering optimizations. Thus, rather than creating a single ElevationGrid that spans the entire floor or terrain of the world, it is better to create a series of ElevationGrids that grid together to form the entire floor or terrain of the world. Choose a size that also lends itself to effective level of detail. Then, create an LOD for each ElevationGrid node to increase rendering performance for sections that are a reasonable distance away. Experiment with different sizes by conducting performance tests in the browser. Be careful to match the seams between the various levels of adjacent ElevationGrids.

P[i,j].x = xSpacing × i P[i,j].y = height[ i + j × xDimension] P[i,j].z = zSpacing × j where 0 <= i < xDimension and 0 <= j < zDimension, and P[0,0] is height[0] units above/below the origin of the local coordinate system

QuadColor[i,j] = Color[ i + j × (xDimension-1)] where 0 <= i < xDimension-1 and 0 <= j < zDimension-1, and QuadColor[i,j] is the colour for the quadrilateral defined by height[i+j×xDimension], height[(i+1)+j×xDimension], height[(i+1)+(j+1)×xDimension] and height[i+(j+1)×xDimension]

VertexColor[i,j] = Color[ i + j × xDimension] where 0 <= i < xDimension and 0 <= j < zDimension, and VertexColor[i,j] is the colour for the vertex defined by height[i+j×xDimension]

QuadNormal[i,j] = Normal[ i + j × (xDimension-1)] where 0 <= i < xDimension-1 and 0 <= j < zDimension-1, and QuadNormal[i,j] is the normal for the quadrilateral defined by height[i+j×xDimension], height[(i+1)+j×xDimension], height[(i+1)+(j+1)×xDimension] and height[i+(j+1)×xDimension]

VertexNormal[i,j] = Normal[ i + j × xDimension] where 0 <= i < xDimension and 0 <= j < zDimension, and VertexNormal[i,j] is the normal for the vertex defined by height[i+j×xDimension]

VertexTexCoord[i,j] = TextureCoordinate[ i + j × xDimension] where 0 <= i < xDimension and 0 <= j < zDimension, and VertexTexCoord[i,j] is the texture coordinate for the vertex defined by height[i+j×xDimension]

TIP: Note that the default texture mapping produces a texture that is upside down when viewed from the positive Z-axis. To orient the texture to a more intuitive mapping, use a TextureTransform node to reverse the t texture coordinate, like this:

     Shape { 
       appearance Appearance { 
         textureTransform TextureTransform { scale 1 -1 } 
       } 
       geometry ElevationGrid { ... } 
     }

This will produce a compact ElevationGrid with texture mapping that aligns to the natural orientation of the image. Note that this only works if the texture is repeated (default). If the texture is not repeated, you need to set the translation field of TextureTransform to translation 0 1. Alternatively, you can specify texture coordinates in the texCoord field that map the first height coordinate to an s and t of (0,1), the last height to (1,0) and so on; this will produce larger files, though.

TECHNICAL NOTE: Most interactive renderers do not draw quadrilaterals directly, but instead split them into triangles before rendering. The VRML specification does not specify how this should be done for ElevationGrid. Implementations are free to do whatever their underlying rendering libraries do. If your ElevationGrids are highly irregular, forming highly nonplanar quadrilaterals, then results may vary between implementations.

TECHNICAL NOTE: ElevationGrid is specified in the geometry field of a Shape node. Like all other geometry nodes, it may not be directly used as the child of a grouping node.

ElevationGrid was added to VRML 2.0 as a compact way of representing terrain. It is not a fundamental node; its functionality is a subset of what can be accomplished with the more general IndexedFaceSet node. Because terrain is common in virtual worlds (and because 2D grids with a value at each grid point are a very common data type used in many different applications) and because ElevationGrid is so much smaller than the equivalent IndexedFaceSet, it was added to the specification. For example, a 10 × 10 ElevationGrid requires a specification of 10 × 10 = 100 heights, plus two integers and two floats for the dimensions and spacing, or 102 floating point and two integer values. Accomplishing the equivalent using an IndexedFaceSet requires 10 × 10 = 100 3D vertices, plus 81 × 5 = 405 integer indices (81 quadrilaterals plus end-of-face markers), or 300 floating point and 405 integer values. Even assuming that compression will make integer indices one-fourth as big as floating point coordinates, the Elevation-Grid is still about four times smaller.

The height field of ElevationGrid is not completely exposed; you can set it using set_height, but there is no height_changed eventOut that you can route from or read from a Script. This was done to allow efficient implementations that convert ElevationGrids into the equivalent IndexedFaceSet (or whatever representation is best for the underlying rendering library). If height were exposed, then such implementations would be forced to maintain the height array. Since it isn't, implementations can free that storage after the conversion is done.

EXAMPLE (click to run): The following example illustrates use of the ElevationGrid node. Note the default texture map orientation on the first ElevationGrid and how TextureTransform is used on the second ElevationGrid to orient the texture more naturally:

#VRML V2.0 utf8
Transform { children [
  Shape {
    geometry DEF EG ElevationGrid { 
      xDimension 5
      xSpacing 1
      zDimension 4
      zSpacing 1
      height [          # 5x4 array of heights
        0 .707 1 .707 0
        0 .47 .667 .47 0
        0 .236 .33 .236 0
        0 0 0 0 0
      creaseAngle 0.8
    }
    appearance Appearance { 
      material DEF M Material { diffuseColor 1 1 1 }
      texture DEF IT ImageTexture { url "marble2.gif" }
    }
  }
  Transform {
    translation 4.3 0 0
    children Shape {
      geometry ElevationGrid {
        xDimension 5
        xSpacing 1
        zDimension 4
        zSpacing 1
        height [          # 5x4 array of heights
          0 .707 1 .707 0
          0 .47 .667 .47 0
          0 .236 .33 .236 0
          0 0 0 0 0
        ]
        creaseAngle 0.8
      }
      appearance Appearance {
        material USE M
        texture USE IT
        textureTransform TextureTransform { scale 1 -1 }
      }
    }
  }
  DirectionalLight { direction -0.80 -0.6 0 }
  Viewpoint { position 3 2 8 }
  Background { skyColor 1 1 1 }
]}

3.17 ElevationGrid

Figure 3-20: ElevationGrid node