Reading the G-Buffer

I'm porting a sensor simulation from TGE to T3D. In TGE I would read the depth buffer and calculate the distance to bunch of points. I know with T3D with Advanced Rendering turned on it uses differed rendering, so how to I read the G-Buffer into main memory and how do I index into the depth buffer data?

If I turn Advanced Rendering off can I just read the depth buffer as in TGE or does it still use a G-Buffer?

In the TGE I would call:

glReadPixels( 0, 0, currentRes.w, currentRes.h, GL_DEPTH_COMPONENT, GL_FLOAT, mDepthBufferStorage );

to read the depth buffer and use the following function to calculate the distance to a point in the rendered scene given an azimuth and elevation relative to the center of the screen.

float GetRange(const double azimuth, const double elevation )
{
double cosAzimuth = cos(azimuth);
double sinAzimuth = sin(azimuth);
double cosElevation = cos(elevation);

// Rotate a vector by elevation and azimuth
// (0,1,0) * rotX( elevation ) * rotZ( azimuth )
//
// x = sin( azimuth ) * cos( elevation )
// y = cos( azimuth ) * cos( elevation )
// z = -sin( elevation )

Point3F pt;
pt.x = sinAzimuth * cosElevation;
pt.y = cosAzimuth * cosElevation;
pt.z = -sin(elevation);

double oneOverY = 1.0 / pt.y;

// Convert that to screen space
int xOffset = (int)((pt.x * oneOverY * halfScreenWidthDivTanHalfFOV) + halfScreenWidth);
int yOffset = (int)((pt.z * oneOverY * halfScreenHeight) + halfScreenHeight);

// These test are probably not necessary
// Cap. the X offset to a valid range
if(xOffset < 0)
xOffset = 0;
else if(xOffset >= (int)width)
xOffset = width - 1;

// Cap. the Y offset to a valid range
if(yOffset < 0)
yOffset = 0;
else if(yOffset >= (int)height)
yOffset = height - 1;

// Calculate the offset into the depth buffer for X
float * baseOffset = mDepthBufferStorage + (width * yOffset) + xOffset;

// Takes the depth buffer value and converts into a Z depth parallel to the front render plan and then multiplies
// it by the depth adjustment to get the length of the ray.
double distance = (nearTimesFarField)/(zBufferFarField - (*baseOffset)*(farMinusNearField));

// Calculate the length of the ray give the distance perpendicular to the front plan
distance *= oneOverY;

return (float)distance;
}