Light | Dark

# docs.GL

OpenGL 3
OpenGL 2

# glEvalMesh

## Name

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 https://web.archive.org/web/20171022161616/http://oss.sgi.com/projects/FreeB/.

Think you can improve this page? Edit this page on GitHub.