Billboard(Z) not really acting like a billboard

Quote:Given a VectorF camVec which is a normalized vector...

Point3F camVec = cameraPos - getRenderPosition();
		camVec.normalize();
		// Get our current render transform matrix.
		MatrixF renderMat = getRenderTransform();
		// 3 vectors we'll use to hold our x y and z rotation vectors.
		VectorF axisX, axisY, axisZ;
		switch(bbType) {
			case BillboardAll:
				//not sure how to approach this
				break;
			case BillboardXAxis:
				renderMat.getColumn(0, &axisX);
				axisX.normalize();
				axisY = mCross(camVec, axisX);
				axisY.normalize();
				axisZ = mCross(axisX, axisY);
				axisZ.normalize();
				renderMat.setColumn(1, axisY);
				renderMat.setColumn(2, axisZ);
				break;
			case BillboardYAxis:
				renderMat.getColumn(1, &axisY);
				axisY.normalize();
				axisZ = mCross(camVec, axisY);
				axisZ.normalize();
				axisX = mCross(axisY, axisZ);
				axisX.normalize();
				renderMat.setColumn(0, axisX);
				renderMat.setColumn(2, axisZ);
				break;
			case BillboardZAxis:
				// Start by pulling the Z axis from our current render transform.
				// This is the axis we don't wish to change.
				renderMat.getColumn(2, &axisZ);
				axisZ.normalize();
				// Now we'll determine the X axis as a cross between camVec and Z.
				// This will give us an X which is perpendicular to both the camera and Z.
				// Note that the Right Hand Rule determines the order of the cross.
				axisX = mCross(camVec, axisZ);
				axisX.normalize();
				// Now the object's "right" (X) should be perpendicular to the camera, and 
				// facing "left" from the camera's point of view.
				// Finally, we need a Y which is perpendicular to both the other rotation axes.
				// And again, the order is important.
				axisY = mCross(axisZ, axisX);
				axisY.normalize();
				// Y or "forward" should now face in the  direction of the camera, but still be
				// perpendicular to X and Z.
				// That leaves us with 3 perpendicular vectors. Z is unchanged, so the object
				// is still "upright", but Y now faces toward the camera.
				// All that's left is to put the new axis into the rotation matrix, like so:   
				renderMat.setColumn(0, axisX);
				renderMat.setColumn(1, axisY);
				// Column 2 (the third column) is axisZ. This we didn't change, so there's
				// no need to set it again.
				break;
		}
		dglMultMatrix(&renderMat); // and we're done.

// Get our current render transform matrix.
MatrixF renderMat = getRenderTransform();

// 3 vectors we'll use to hold our x y and z rotation vectors.
VectorF axisX, axisY, axisZ;

// Start by pulling the Z axis from our current render transform.
// This is the axis we don't wish to change.
renderMat.getColumn(2, &axisZ);

// Now we'll determine the X axis as a cross between camVec and Z.
// This will give us an X which is perpendicular to both the camera and Z.
// Note that the Right Hand Rule determines the order of the cross.
axisX = mCross(camVec, axisZ);

[i]// Must normalize axisX
// Also, we should check for a zero length vector here. If camVec is 
// parallel to axisZ, axisX will be of zero length. And if we normalize
// a zero length vector, we'll crash the game with a divide by zero.
if (!axisX.isZero()) {
   axisX.normalize();
} else {
   axisX.set(1,0,0);
}[/i]

// Now the object's "right" (X) should be perpendicular to the camera, and 
// facing "left" from the camera's point of view.

// Finally, we need a Y which is perpendicular to both the other rotation axes.
// And again, the order is important.
axisY = mCross(axisZ, axisX);

// Y or "forward" should now face in the  direction of the camera, but still be
// perpendicular to X and Z.

// That leaves us with 3 perpendicular vectors. Z is unchanged, so the object
// is still "upright", but Y now faces toward the camera.

// All that's left is to put the new axis into the rotation matrix, like so:	
renderMat.setColumn(0, axisX);
renderMat.setColumn(1, axisY);

// Column 2 (the third column) is axisZ. This we didn't change, so there's
// no need to set it again.

dlgMultMatrix(&renderMat); // and we're done.

void SceneObject::billboardModelView(Point3F cameraPos, S32 bbType)
{
	if (bbType > 0) {
		Point3F camVec = cameraPos - getRenderPosition();
		camVec.normalize();
		// Get our current render transform matrix
		MatrixF renderMat = getRenderTransform();
		// 3 vectors we'll use to hold our x y and z rotation vectors.
		VectorF axisX, axisY, axisZ;
		switch(bbType) {
			case BillboardAll:
				//this forces a positive z orientation, which is ok for most situations
				renderMat = MathUtils::createOrientFromDir(camVec);
				renderMat.setPosition(getRenderPosition());
				break;
			case BillboardXAxis:
				renderMat.getColumn(0, &axisX);
				axisY = mCross(camVec, axisX);
				if (!axisY.isZero()) {
					axisY.normalize();
				} else {
					axisY.set(0,1,0);
				}
				axisZ = mCross(axisX, axisY);
				renderMat.setColumn(1, axisY);
				renderMat.setColumn(2, axisZ);
				break;
			case BillboardYAxis:
				renderMat.getColumn(1, &axisY);
				axisZ = mCross(camVec, axisY);
				if (!axisZ.isZero()) {
					axisZ.normalize();
				} else {
					axisZ.set(0,0,1);
				}
				axisX = mCross(axisY, axisZ);
				renderMat.setColumn(0, axisX);
				renderMat.setColumn(2, axisZ);
				break;
			case BillboardZAxis:
				// Start by pulling the Z axis from our current render transform.
				// This is the axis we don't wish to change.
				renderMat.getColumn(2, &axisZ);
				// Now we'll determine the X axis as a cross between camVec and Z.
				// This will give us an X which is perpendicular to both the camera and Z.
				// Note that the Right Hand Rule determines the order of the cross.
				axisX = mCross(camVec, axisZ);
				// Must normalize axisX
				// Also, we should check for a zero length vector here. If camVec is 
				// parallel to axisZ, axisX will be of zero length. And if we normalize
				// a zero length vector, we'll crash the game with a divide by zero.
				if (!axisX.isZero()) {
					axisX.normalize();
				} else {
					axisX.set(1,0,0);
				}
				// Now the object's "right" (X) should be perpendicular to the camera, and 
				// facing "left" from the camera's point of view.
				// Finally, we need a Y which is perpendicular to both the other rotation axes.
				// And again, the order is important.
				axisY = mCross(axisZ, axisX);
				// Y or "forward" should now face in the  direction of the camera, but still be
				// perpendicular to X and Z.
				// That leaves us with 3 perpendicular vectors. Z is unchanged, so the object
				// is still "upright", but Y now faces toward the camera.
				// All that's left is to put the new axis into the rotation matrix, like so:   
				renderMat.setColumn(0, axisX);
				renderMat.setColumn(1, axisY);
				// Column 2 (the third column) is axisZ. This we didn't change, so there's
				// no need to set it again.
				break;
		}
		dglMultMatrix(&renderMat); // and we're done.	
	} else {
		//if non-billboarded, just use the normal transform
		dglMultMatrix( &getRenderTransform() );
	}
}