OpenGL options

The graphical engine of GiD uses the OpenGL library

Visualization mode:

- Fast visualization mode: GiD will use the hardware acceleration provided by the driver to accelerate the visualization of the models. If some problems appear, pleas update your driver or use the Safe visualization mode.
- Safe visualization mode: GiD will render the model and mesh using only the CPU, i.e. will not use hardware acceleration of the graphics card. This will make some artifacts disappear but models and meshes will be drawn slower.

Selection lines by software(emulateFrontBuffer): on some configurations dynamic lines, such the ones used when selecting entities or zooming in or out, are not drawn or are drawn leaving some ghost lines behind the mouse cursor. Select this option of make these problems disappear. Particularly on Intel graphics with fast visualization mode, this option should be enabled as dynamics lines are not supported by the Intel graphic drivers.
Antialiasing of points, lines and polygons: Reduces the 'staircase' effect when drawing lines, points...
Selection only visible: experimental option to graphically select entities coding ids by colors. As secondary effect will select only visible parts (the final id-colors of the image created internally for this selection).

Drawing method
Several algorithms are used in GiD to draw meshes faster, but which rely on the underlying hardware at different levels. Faster methods needs good hardware graphics and driver support, slower methods are safer and independent of the graphics capabilities available.

Method:

- Vertex buffer objects: is the fastest method, but it requires OpenGL 1.5 or higher, and the Fast visualization mode. Extra memory of the graphics card is used.
- Vertex array: requires OpenGL 1.1, and can work also with Safe visualization mode too. Extra main memory is used.
- Display lists: requires OpenGL 1.0, basic acceleration if used with the Fast visualization mode. Extra memory of the graphics card is used.
- Immediate mode: requires OpenGL 1.0, is the slowest but most robust method and requires less memory than the other methods.

Render normal: if set, the preprocess mesh is colored using the layer color. If not set, then the Element color is used as defined in Colors.
Under Draw spheres as and Draw points as, the speed and quality of the mesh element type sphere and point can be configured, as there are several methods to draw spheres and points:

- Textures (Fast): an image is used to drawn spheres / points. it's a compromise between quality and speed.
- Mesh ( Slow): a triangle mesh, between 4 and 630 triangles big, is used to drawn each sphere / point for a nice quality.
- Square ( Fastest): draws spheres / points as a square. This is the fastest drawing method for point and sphere elements.

Exact contour fills (only with Display list and Immediate mode drawing methods, only in postprocess): if set, each element is subdivided into single color sub-elements according to the color scale, in order to get a better quality and limit representation of the color bands. This option is only available with Display lists or Immediate mode drawing methods.

Fast rotation
This allows fast rotation of the object. If this option is set various further options are available, though these only apply when rotating.

To draw or not to draw each type of entity when rotating.
Always Geometry: With this option set, when you view and rotate the mesh, the geometry is drawn instead.
Draw graphic objects: If this option is not set, when rotating the geometry, some graphical and temporal objects like normals or materials or conditions symbols are not drawn.

In postprocess mode, when this options is enabled the model is drawn using a simplified mesh according to the Simplified view settings in Postprocess section.

Summary of features available in Safe and Fast visualization modes:

	Safe visualization mode ( MS Windows)	Fast visualization mode
Drawing: immediate mode	saves memory / slow	saves memory / slow
Drawing: display list ( DL)	a bit faster ( uses main memory)	faster ( uses card's memory)
Drawing: vertex array	a bit faster ( uses less memory than DL)	a bit faster ( uses main memory)
Drawing: vertex buffer object	No ( requires OpenGL 1.5)	fastest ( uses less card's memory than DL)
Effect: stereoscopy ( 3D)	Yes	Yes
Effect: mirror plane	Yes	Yes
Effect: render reflection	No ( requires OpenGL 1.3)	Yes
Effect: shadows	No ( requires OpenGL 1.5)	Yes
Effect: shiny contour fills (Options --> Contour --> Bright Color)	No ( requires OpenGL 1.2)	Yes
Recommended mesh size	< 1,000,000 triangles	depends on the graphic's card memory available (check Help --> About --> More)

Browser not supported