http://www.opengl.org/wiki/Vertex_Texture_Fetch

Vertex Texture Fetch

The following article discusses Vertex Texture Fetch feature of todays GPUs.

Vertex Texture Fetch will be referred to as VTF from now on.
Texture image units will be referred to as TIU.
VS means vertex shader
FS means fragment shader

What version of GL supports VTF?
In order to be able to do VTF, you need shader support. GLSL has been made core since GL 2.0.
You also need a GPU that supports VTF.
As of GL 2.1, texture float formats are not core yet. You need to check if GL_ARB_texture_float is present.
http://www.opengl.org/registry/specs/ARB/texture_float.txt
In GL 3.0, floating point formats became a core feature.

GPUs that support VTF use the same TIUs as the fragment shader. This means that you can bind a texture to TIU 1 and sample that same texture in the vertex shader and also the fragment shader. To bind the texture, it is rather simple :

 glActiveTexture(GL_TEXTURE1);
 glBindTexture(GL_TEXTURE_2D, textureID);

In order to know how many TIUs your vertex shader has access to, call

 int MaxVertexTextureImageUnits;
 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &MaxVertexTextureImageUnits);
 int MaxCombinedTextureImageUnits;
 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &MaxCombinedTextureImageUnits);

and GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS is the TUI number accessible from your VS and FS combined.
If in your VS and FS, you access the same texture, that counts like accessing 2 TIUs.

An issue with accessing a texture is the texture format. Your GPU might support a wide range of formats that can be accessed by the TIU of the FS but the TIU of the VS simply doesn‘t support certain formats. For example, nVidia has published Vertex_Format.pdf when Gf6 was released
Gf 6 supports only GL_TEXTURE_2D of format GL_LUMINANCE32F_ARB and GL_RGBA32F_ARB. It doesn‘t support any of the other floating point formats or fixed point formats. There is no floating point compressed format.
All other formats besides GL_LUMINANCE32F_ARB and GL_RGBA32F_ARB cause the VS to run in software mode.
Gf 7 is similar to the Gf6.
Gf 8 is a DX10 level GPU and all DX10 level GPUs should support VTF with the same formats supported by the fragment pipe.

ATI/AMD :
ATI/AMD chose not to have VTF in their SM 3.0 GPUs.
X300 up to X1950. All of their standard X series.
They said it would be too slow. It would be better to do Render_To_VertexBuffer (R2VB).
In OpenGL, to do R2VB you would need PBO support. http://www.opengl.org/registry/specs/ARB/pixel_buffer_object.txt
PBO became core in GL 2.1 and ATI‘s driver do support GL 2.1.
ATI‘s DX10 parts, in other words all their GPUs with the HD in the name, support VTF.
ATI‘s driver does report 16 for GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS but users are saying that their shaders don‘t work.

Example code :

 uint vertex_texture;
 glGenTextures(1, &vertex_texture);
 glBindTexture(GL_TEXTURE_2D, vertex_texture);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 //Linear filter might cause a fallback to software rendering so we are using GL_NEAREST
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 //Linear filter might cause a fallback to software rendering so we are using GL_NEAREST_MIPMAP_NEAREST
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
 //Make sure your GPU support mipmaps with floating point textures
 glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAPS, GL_TRUE);
 glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE32F_ARB, width, height, 0, GL_LUMINANCE, GL_FLOAT, data);

If you setup some unsupported filter mode or wrap mode, or some unsupported texture format, it will fall to software vertex processing.

Another thing to remember is that the GPU doesn‘t know which mipmap to use. It has no way to compute the lambda factor.
You need to choose the mipmap in the VS yourself.
Here is an example of a VS.
Notice how the example uses texture2DLod() and it chooses mipmap 0.

 attribute vec2 inTexCoord;
 uniform sampler2D Texture0;
 uniform mat4 ProjectionModelviewMatrix;
 varying vec2 TexCoord;
 void main()
 {
     vec4 texel, newVertex;
     //Read the texture offset. Offset in the z direction only
     texel = texture2DLod(Texture0, inTexCoord, 0.0);
     newVertex = gl_Vertex;
     newVertex.z += texel.x;
     gl_Position = ProjectionModelviewMatrix * newVertex;
     TexCoord = inTexCoord;
 }

Vertex Fetch Texture (VTF)