Trouble with frustum culling (Video included)

OpenGL Development
#1

Hello :slight_smile:

(I did already post this at OpenGL.org, but since I know there are some OpenGL genii here, I thought I would ask you guys. I hope it’s not too offensive :))

I’m working on an OpenGL application and I’m having trouble with my objects being clipped undesirably by frustum culling

The scene consists of a number of objects on an invisible plane. You can pan around by left clicking and dragging on the invisible plane (This does not translate the plane, it translates the camera). You can rotate the invisible plane by right clicking and dragging (This rotates the plane).

The problem comes when you rotate the plane and then pan so that the objects pass through the far plane of the frustum.

I would like my objects to never get clipped, no matter how far back you push them.

I’m currently using a constant frustum defined by

frustum.left = -1.0;
frustum.right = 1.0;
frustum.top = 1.0;
frustum.bottom = -1.0;
frustum.near = 5.0;
frustum.far = 500.0;

but I was thinking perhaps I could update the projection matrix and frustum every frame, ensuring that the near plane touches the front of the bounding box of my objects and the far plane touches the back of the bounding box of my objects.

Does anyone have any advice which could help me get rid of this unwanted clipping?

Please see accompanying video which visually describes the problem here: http://screencast.com/t/0L4oS1t9T

Thanks

#2

calculating the near and far plane each frame would be the easiest way to do it for you.
When one need an extreme view distance then there is also the possibility to do logarithmic depth, but you won’t need this for such a small example

#3

You can’t have your far plane infinitely far away, since that would require infinite precision in your Z-buffer. The higher the ratio is between the near and far plane, the lower the precision you get. With recalculated near and far planes, in a worst case scenario you’d have some objects nearby and some objects far away, in which case the precision would be incredibly bad for both nearby and far away objects, and you could possible experience a terrible artifact known as z-fighting, in which case objects that are overlapping start to bleed through each other.

Another option is to use a multi-pass technique. For example, you can have 2 passes, one which draws stuff between 1.0 and 500.0, and another that draws stuff from 500.0 to 250 000. You can then draw each pass starting with the furthest one, so we draw all stuff between 500.0 and 250 000 first. Then we clear the depth buffer again, change the projection matrix and draw the stuff inside the next frustum. By doing frustum culling on the CPU only objects which intersect both frustums have to be drawn twice.
PS: I’m not exactly sure if the example values I provided are appropriate, it was just to explain what I meant.

#4

Cool. Fitting the frustum to the bounding box of the objects seems to have worked well :slight_smile:

http://screencast.com/t/jzyBQ8Fx

Thanks


	matrix = this.camera.getTransform();
	matrix.multiplyMatrix(Matrix4.createRotationX(this.planeRotation.x));
	matrix.multiplyMatrix(Matrix4.createRotationY(this.planeRotation.y));
	
	boundingBox = this.createBoundingBox(this.things, matrix);
	
	originalSettings = {left: -1.0, right: 1.0, top: 1.0, bottom: -1.0, near: 5.0};
	newSettings = {};

	angle = Math.atan(originalSettings.right / originalSettings.near);
	
	buffer = 1.0;
	
	newSettings.near   = Math.max(-boundingBox.maxCoords.z, 2.0) - buffer;
	newSettings.far    = Math.max(-boundingBox.minCoords.z, 2.0) + buffer;
	newSettings.left   = -newSettings.near * Math.tan(angle);
	newSettings.right  = newSettings.near * Math.tan(angle);
	newSettings.bottom = -newSettings.near * Math.tan(angle);
	newSettings.top    = newSettings.near * Math.tan(angle);
	
	aspectRatio = this.glViewportWidth / this.glViewportHeight;
	
	if (aspectRatio > 1.0) {
		newSettings.left *= aspectRatio;
		newSettings.right *= aspectRatio;
	} else {
		newSettings.bottom /= aspectRatio;
		newSettings.top /= aspectRatio;
	}
	
	this.frustum.near   = newSettings.near;
	this.frustum.far    = newSettings.far;
	this.frustum.left   = newSettings.left;
	this.frustum.right  = newSettings.right;
	this.frustum.bottom = newSettings.bottom;
	this.frustum.top    = newSettings.top;