void CVLOut::WriteCamera()
{
	CtsxVector3f camloc, camto, upaxis, pos, dir;

	upaxis.x = 0.0f;
	upaxis.y = 0.0f;
	upaxis.z = 1.0f;

	tsxGNODE *pCam = (tsxGNODE*)tsxAViewGetCameraObj();

	if (tsxGNodeGetUnits(pCam) != e_tsxUNITS_METERS)
		tsxGNodeSetUnits(pCam, e_tsxUNITS_METERS);

	tsxGNODE *pTarget = NULL;
	tsxGNodeGetLookAt(pCam, &pTarget);

	CtsxAxes3f camaxes;
	tsxGNodeGetAxesOrientation(pCam, &camaxes);
	tsxGNodeGetLocation(pCam, &camloc);
	
	tsxAViewGetPosition(&pos);
	tsxAViewGetDirection(&dir);

	if (pTarget)
	{
		if (tsxGNodeGetUnits(pTarget) != e_tsxUNITS_METERS)
			tsxGNodeSetUnits(pTarget, e_tsxUNITS_METERS);
		tsxGNodeGetLocation(pTarget, &camto);
	}
	else
	{		
		camto.x = pos.x + dir.x;
		camto.y = pos.y + dir.y;
		camto.z = pos.z + dir.z;
	}


	
	float angle = tsxAViewGetBankAngle();

	CtsxVector3f ortho_proj, normal;
	CtsxVector3f up = { 0.0, 0.0, 1.0 };
	CtsxTxmx3f rot_matrix;
	if(dir.z > 0.005) 
	{
		ortho_proj = dir; ortho_proj.z = 0;

		tsxXProdVec3f( normal, dir ,ortho_proj);
		tsxNormalize3f(normal);
		tsxMakeRotMx3f(pos ,normal,(float)(-3.141593/2), &rot_matrix, NULL);
		tsxRotateVecs3f(1,&up, &dir ,rot_matrix);
		tsxNormalize3f(up);
	}
	else if (dir.z < -0.005)
	{
			ortho_proj = dir; ortho_proj.z = 0;
		tsxXProdVec3f( normal, dir ,ortho_proj);
		tsxNormalize3f(normal);
		tsxMakeRotMx3f(pos ,normal, (float)(3.141593/2), &rot_matrix, NULL);
		tsxRotateVecs3f(1,&up, &dir ,rot_matrix);
		tsxNormalize3f(up);
	}
	else // dir.z is perpendicular to up.z
	{
		up.x = 0.0;
		up.y = 0.0;
		up.z = 1.0;
	}


	if (angle)
	{
		tsxMakeRotMx3f(pos ,dir, -angle , &rot_matrix, NULL);
		tsxRotateVecs3f(1,&upaxis,&up ,rot_matrix);
		tsxNormalize3f(upaxis);
	}
	
	
	
	

	float zoom = tsxAViewGetZoom();
	float factor = 2.5f;
	factor *= zoom;
	factor *= FormatAspect;
	float fov;
	
	if (LensModel == 0) // perspective
		fov = tsxRad2Deg((float)atan(fabs(1./factor)))*2.f;
	else
		fov = FieldOfView;

	
	float outformataspect = -FormatAspect;

	
	if (IsBinary)
	{
		viCAMERA *cam;
		cam = viNewCamera();

		viSetVector(&cam->Location, camloc.x, camloc.y, camloc.z);
		viSetVector(&cam->LookAt, camto.x, camto.y, camto.z);
		viSetVector(&cam->UpAxis, upaxis.x, upaxis.y, upaxis.z);
		viSetInt(cam->Format.X, FormatWidth);
		viSetInt(cam->Format.Y, FormatHeight);
		viSetDbl(cam->FieldOfView, fov);
		viSetDbl(cam->FrameAspectRatio, outformataspect);
		if (UseDOF)
		{
			viSetDbl(cam->DepthOfField.Aperture, DOFApertureSize);
			viSetDbl(cam->DepthOfField.Distance, DOFFocalDistance);
			viSetInt(cam->DepthOfField.Samples, DOFSamples);
		}
		if (AALevel > 0)
		{
			viSetInt(cam->Antialiasing, AALevel);
		}
		if (Undersampling > 0)
		{
			viSetInt(cam->Undersampling, Undersampling);
		}
		viSetFlt(cam->Exposure.Gain, CamGain);
		viSetFlt(cam->Exposure.Gamma, CamGamma);
		switch(LensModel)
		{
		case 0:
			viSetInt(cam->LensModel, LENS_PERSPECTIVE);
			break;
		case 1:
			viSetInt(cam->LensModel, LENS_ORTHOGRAPHIC);
			break;
		case 2:
			viSetInt(cam->LensModel, LENS_WIDE_ANGLE);
			break;
		case 3:
			viSetInt(cam->LensModel, LENS_FISHEYE);
			break;
		case 4:
			viSetInt(cam->LensModel, LENS_PANORAMIC);
			break;
		case 5:
			viSetInt(cam->LensModel, LENS_OMNIMAX);
			break;
		}
			
		if (UsePixelFilter)
		{
			switch(PixelFilterType)
			{
			case 0:
				viSetInt(cam->PixelFilter.Function, BOXfilter);
				break;
			case 1:
				viSetInt(cam->PixelFilter.Function, TRIANGLEfilter);
				break;
			case 2:
				viSetInt(cam->PixelFilter.Function, CATMULLROMfilter);
				break;
			case 3:
				viSetInt(cam->PixelFilter.Function, GAUSSIANfilter);
				break;
			case 4:
				viSetInt(cam->PixelFilter.Function, SINCfilter);
				break;
			case 5:
				viSetInt(cam->PixelFilter.Function, DISKfilter);
				break;
			case 6:
				viSetInt(cam->PixelFilter.Function, BESSELfilter);
				break;
			}
			viSetFlt(cam->PixelFilter.xWidth, PixelFilterXWidth);
			viSetFlt(cam->PixelFilter.yWidth, PixelFilterYWidth);
		}


		viDumpCamera(cam, bvib);
		free(cam);
	}
	else
	{
		vib.WriteString("Camera [\n");
		s.Format("	(%f,%f,%f), (%f,%f,%f), (%f,%f,%f)\n", camloc.x, camloc.y, camloc.z, camto.x, camto.y, camto.z, upaxis.x, upaxis.y, upaxis.z);
		vib.WriteString(s);
		s.Format("	FieldOfView %f\n", fov);
		vib.WriteString(s);
		s.Format("	Format (%d, %d)\n", FormatWidth, FormatHeight);
		vib.WriteString(s);
		s.Format("	FrameAspectRatio %f\n", outformataspect);
		vib.WriteString(s);
		if (UseDOF)
		{
			s.Format("	DepthOfField (%f, %f, %d)\n", DOFApertureSize, DOFFocalDistance, DOFSamples);
			vib.WriteString(s);
		}
		if (AALevel > 0)
		{
			s.Format("	Antialiasing %d\n", AALevel);
			vib.WriteString(s);
		}
		if (Undersampling > 0)
		{
			s.Format("	Undersampling %d\n", Undersampling);
			vib.WriteString(s);
		}
		s.Format("	Exposure (%f, %f)\n", CamGain, CamGamma);
		vib.WriteString(s);
		
		switch(LensModel)
		{
		case 0:
			vib.WriteString("	LensModel PERSPECTIVE\n");
			break;
		case 1:
			vib.WriteString("	LensModel ORTHOGRAPHIC\n");
			break;
		case 2:
			vib.WriteString("	LensModel WIDE_ANGLE\n");
			break;
		case 3:
			vib.WriteString("	LensModel FISHEYE\n");
			break;
		case 4:
			vib.WriteString("	LensModel PANORAMIC\n");
			break;
		case 5:
			vib.WriteString("	LensModel OMNIMAX\n");
			break;
		}

		if (UsePixelFilter)
		{
			switch(PixelFilterType)
			{
			case 0:
				s.Format("	PixelFilter(BOXfilter,%f,%f)\n", PixelFilterXWidth, PixelFilterYWidth);
				vib.WriteString(s);
				break;
			case 1:
				s.Format("	PixelFilter(TRIANGLEfilter,%f,%f)\n", PixelFilterXWidth, PixelFilterYWidth);
				vib.WriteString(s);
				break;
			case 2:
				s.Format("	PixelFilter(CATMULLROMfilter,%f,%f)\n", PixelFilterXWidth, PixelFilterYWidth);
				vib.WriteString(s);
				break;
			case 3:
				s.Format("	PixelFilter(GAUSSIANfilter,%f,%f)\n", PixelFilterXWidth, PixelFilterYWidth);
				vib.WriteString(s);
				break;
			case 4:
				s.Format("	PixelFilter(SINCfilter,%f,%f)\n", PixelFilterXWidth, PixelFilterYWidth);
				vib.WriteString(s);
				break;
			case 5:
				s.Format("	PixelFilter(DISKfilter,%f,%f)\n", PixelFilterXWidth, PixelFilterYWidth);
				vib.WriteString(s);
				break;
			case 6:
				s.Format("	PixelFilter(BESSELfilter,%f,%f)\n", PixelFilterXWidth, PixelFilterYWidth);
				vib.WriteString(s);
				break;
			}
		}

		vib.WriteString("]\n");
	}

}