1991-2006 Silicon Graphics, Inc.

glEvalMesh

3G

glEvalMesh

compute a one- or two-dimensional grid of points or lines

# C Specification

                    void glEvalMesh1
                    GLenum mode
                    GLint i1
                    GLint i2

## Parameters

`mode`

- In `glEvalMesh1`, specifies whether to compute a one-dimensional mesh of points or lines. Symbolic constants `GL_POINT` and `GL_LINE` are accepted.

`i1`

`i2`

- Specify the first and last integer values for grid domain variable i.

## C Specification

                    void glEvalMesh2
                    GLenum mode
                    GLint i1
                    GLint i2
                    GLint j1
                    GLint j2

## Parameters

`mode`

- In `glEvalMesh2`, specifies whether to compute a two-dimensional mesh of points, lines, or polygons. Symbolic constants `GL_POINT`, `GL_LINE`, and `GL_FILL` are accepted.

`i1`

`i2`

- Specify the first and last integer values for grid domain variable i.

`j1`

`j2`

- Specify the first and last integer values for grid domain variable j.

## Description

glMapGrid

and `glEvalMesh` are used in tandem to efficiently generate and evaluate a series of evenly-spaced map domain values. `glEvalMesh` steps through the integer domain of a one- or two-dimensional grid, whose range is the domain of the evaluation maps specified by

glMap1

and

glMap2

. `mode` determines whether the resulting vertices are connected as points, lines, or filled polygons.

In the one-dimensional case, `glEvalMesh1`, the mesh is generated as if the following code fragment were executed:

    glBegin( type );
    for ( i = i1; i <= i2; i += 1 )
       glEvalCoord1(

    		              i
    			      ·
    			      Δ
    		              u

    		          +

    		              u
    		              1

    		   );
    glEnd();

where

Δ u = u 2 - u 1 n

and n, u 1 , and u 2 are the arguments to the most recent

glMapGrid1

command. type is `GL_POINTS` if `mode` is `GL_POINT`, or `GL_LINES` if `mode` is `GL_LINE`.

The one absolute numeric requirement is that if i = n , then the value computed from i · Δ u + u 1 is exactly u 2 .

In the two-dimensional case, `glEvalMesh2`, let .cp Δ u = u 2 - u 1 n

Δ v = v 2 - v 1 m

where n, u 1 , u 2 , m, v 1 , and v 2 are the arguments to the most recent

glMapGrid2

command. Then, if `mode` is `GL_FILL`, the `glEvalMesh2` command is equivalent to:

    for ( j = j1; j < j2; j += 1 ) {
       glBegin( GL_QUAD_STRIP );
       for ( i = i1; i <= i2; i += 1 ) {
          glEvalCoord2(

    			        i
    				·
    			        Δ
    		                u

    		            +

    		                u
    		                1

    			    ,

    			        j
    				·
    			        Δ
    		                v

    		            +

    		                v
    		                1

    		     );
          glEvalCoord2(

    			        i
    				·
    			        Δ
    		                u

    		            +

    		                u
    		                1

    			    ,

    			                    j
    				            +
    			                    1

    				·
    			        Δ
    		                v

    		            +

    		                v
    		                1

    		     );
       }
       glEnd();
    }

If `mode` is `GL_LINE`, then a call to `glEvalMesh2` is equivalent to:

    for ( j = j1; j <= j2; j += 1 ) {
       glBegin( GL_LINE_STRIP );
       for ( i = i1; i <= i2; i += 1 )
          glEvalCoord2(

    			        i
    				·
    			        Δ
    		                u

    		            +

    		                u
    		                1

    			    ,

    			        j
    				·
    			        Δ
    		                v

    		            +

    		                v
    		                1

    		     );
       glEnd();
    }

    for ( i = i1;  i <= i2; i += 1 ) {
       glBegin( GL_LINE_STRIP );
       for ( j = j1; j <= j1; j += 1 )
          glEvalCoord2(

    			        i
    				·
    			        Δ
    		                u

    		            +

    		                u
    		                1

    			    ,

    			        j
    				·
    			        Δ
    		                v

    		            +

    		                v
    		                1

    		     );
       glEnd();
    }

And finally, if `mode` is `GL_POINT`, then a call to `glEvalMesh2` is equivalent to:

    glBegin( GL_POINTS );
    for ( j = j1; j <= j2; j += 1 )
       for ( i = i1; i <= i2; i += 1 )
          glEvalCoord2(

    			        i
    				·
    			        Δ
    		                u

    		            +

    		                u
    		                1

    			    ,

    			        j
    				·
    			        Δ
    		                v

    		            +

    		                v
    		                1

    		     );
    glEnd();

In all three cases, the only absolute numeric requirements are that if i = n , then the value computed from i · Δ u + u 1 is exactly u 2 , and if j = m , then the value computed from j · Δ v + v 1 is exactly v 2 .

## Errors

`GL_INVALID_ENUM` is generated if `mode` is not an accepted value.

`GL_INVALID_OPERATION` is generated if `glEvalMesh` is executed between the execution of

glBegin

and the corresponding execution of

glEnd

.

## Associated Gets

glGet

with argument `GL_MAP1_GRID_DOMAIN`

glGet

with argument `GL_MAP2_GRID_DOMAIN`

glGet

with argument `GL_MAP1_GRID_SEGMENTS`

glGet

with argument `GL_MAP2_GRID_SEGMENTS`

## See Also

glBegin

,

glEvalCoord

,

glEvalPoint

,

glMap1

,

glMap2

,

glMapGrid

## Copyright

Copyright 1991-2006 Silicon Graphics, Inc. This document is licensed under the SGI Free Software B License. For details, see http://oss.sgi.com/projects/FreeB/.