Level of detail (LOD)

K

kozle

New member
Hi!

If someone knows something about level of detail (LOD) in comuter graphics, please write me.
- I would like to know if LOD algorithms are implemeted in graphic cards (hardware), or programmers must solve this problem (software implemented).
- Are these algorithms implemented in DirectX or OpenGL
- ...

Thanks for the answers and sorry for my english! :rolleyes:
 
actualy it is a homework, but this is only a part of homework. You see, i must generate a large map, when the map, will be rendered, the horizon of the map should be less precise, becouse of hardware limitations. So they told me that these things are solved with LOD. Then my question kicks in ... :bleh:
 
I don't know much about programming but I think LOD has something to do with video memory. So if you have a small map you could raise the LOD to 0 to get the best result. All i know is that devlopers decide what the LOD is going to be and there are no hardware limitations (except for memory)
 
I believe there are implementations in both software and harware. I worked on the paging landscape scene manager for a project in the past and that LOD was very straightforward as to how far you could see. If you are in a space of terrain, you could see the immediate surrounding terrain spaces but none of the terrain outside the currently visited terrain and the immediate neighboring terrains were rendered. This is a sofware implementation. Now, I believe that OpenGL does not render obects that are too small to see on the screen anyway, which is either software or hardware. I do not know the guts of OpenGL enough to determine whether that is software or hardware or both.
I am also too lazy to figure out the answer to that. But you should research OpenGL some. You may be able to find some answers there. GL.
 
This extension imposes two constraints related to the texture level of
detail parameter LOD, which is represented by the Greek character lambda
in the GL Specification. One constraint clamps LOD to a specified
floating point range. The other limits the selection of mipmap image
arrays to a subset of the arrays that would otherwise be considered.

The level of detail parameter LOD is defined in the first paragraph
of Section 3.8.1 (Texture Minification) of the GL Specification, where
it is represented by the Greek character lambda. This extension
redefines the definition of LOD as follows:

LOD'(x,y) = log_base_2 (Q(x,y))


/ MAX_LOD LOD' > MAX_LOD
LOD = ( LOD' LOD' >= MIN_LOD and LOD' <= MAX_LOD
\ MIN_LOD LOD' < MIN_LOD
\ undefined MIN_LOD > MAX_LOD

The variable Q in this definition represents the Greek character rho,
as it is used in the OpenGL Specification. (Recall that Q is computed
based on the dimensions of the BASE_LEVEL image array.) MIN_LOD is the
value of the per-texture variable TEXTURE_MIN_LOD_SGIS, and MAX_LOD is
the value of the per-texture variable TEXTURE_MAX_LOD_SGIS.

Initially TEXTURE_MIN_LOD_SGIS and TEXTURE_MAX_LOD_SGIS are -1000 and
1000 respectively, so they do not interfere with the normal operation of
texture mapping. These values are respecified for a specific texture
by calling TexParameteri, TexParemeterf, TexParameteriv, or
TexParameterfv with <target> set to TEXTURE_1D, TEXTURE_2D, or
TEXTURE_3D_EXT, <pname> set to TEXTURE_MIN_LOD_SGIS or
TEXTURE_MAX_LOD_SGIS, and <param> set to (or <params> pointing to) the
new value. It is not an error to specify a maximum LOD value that is
less than the minimum LOD value, but the resulting LOD values are
not defined.

LOD is clamped to the specified range prior to any use. Specifically,
the mipmap image array selection described in the Mipmapping Subsection
of the GL Specification is based on the clamped LOD value. Also, the
determination of whether the minification or magnification filter is
used is based on the clamped LOD.

Mipmap Completeness
-------------------

The GL Specification describes a "complete" set of mipmap image arrays
as array levels 0 through p, where p is a well defined function of the
dimensions of the level 0 image. This extension modifies the notion
of completeness: instead of requiring that all arrays 0 through p
meet the requirements, only arrays 0 and arrays BASE_LEVEL through
MAX_LEVEL (or p, whichever is smaller) must meet these requirements.
The specification of BASE_LEVEL was described above. MAX_LEVEL is
specified by calling TexParameteri, TexParemeterf, TexParameteriv, or
TexParameterfv with <target> set to TEXTURE_1D, TEXTURE_2D, or
TEXTURE_3D_EXT, <pname> set to TEXTURE_MAX_LEVEL_SGIS, and <param> set
to (or <params> pointing to) the desired value. The error
INVALID_VALUE is generated if the specified MAX_LEVEL is negative.
If MAX_LEVEL is smaller than BASE_LEVEL, or if BASE_LEVEL is greater
than p, the set of arrays is incomplete.

Array Selection
---------------

Magnification and non-mipmapped minification are always performed
using only the BASE_LEVEL image array. If the minification filter
is one that requires mipmapping, one or two array levels are
selected using the equations in the table below, and the LOD value
is clamped to a maximum value that insures that no array beyond
the limits specified by MAX_LEVEL and p is accessed.

Minification Filter Maximum LOD Array level(s)
------------------- ----------- --------------
NEAREST_MIPMAP_NEAREST M + 0.4999 floor(B + 0.5)
LINEAR_MIPMAP_NEAREST M + 0.4999 floor(B + 0.5)
NEAREST_MIPMAP_LINEAR M floor(B), floor(B)+1
LINEAR_MIPMAP_LINEAR M floor(B), floor(B)+1

where:

M = min(MAX_LEVEL,p) - BASE_LEVEL
B = BASE_LEVEL + LOD

For NEAREST_MIPMAP_NEAREST and LINEAR_MIPMAP_NEAREST the specified
image array is filtered according to the rules for NEAREST or
LINEAR respectively. For NEAREST_MIPMAP_LINEAR and
LINEAR_MIPMAP_LINEAR both selected arrays are filtered according to
the rules for NEAREST or LINEAR, respectively. The resulting values
are then blended as described in the Mipmapping section of the
OpenGL specification.

http://oss.sgi.com/projects/ogl-sample/registry/SGIS/texture_lod.txt

http://www.gamedev.net/community/forums/topic.asp?topic_id=252983

LOD determined by texture level or size of texture.
It can be software rendered or hardware.
Smaller the certain texture = farther away from view source lower LOD.

Hope that helps Google is your friend.


http://glbook.gamedev.net/oglgp.asp

OpenGL Game Programming is available now at the following online booksellers:

* Amazon.com

You should also be able to find it at the following stores

* Borders
* CompUSA
* Barnes and Noble
* Best Buy
 
Last edited:
You must log in or register to reply here.
Back
Top