Renegade/Code/Tools/W3DView/W3DViewDoc.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// W3DViewDoc.cpp : implementation of the CW3DViewDoc class
//

#include "stdafx.h"

#include "w3dview.h"
#include "w3dviewdoc.h"
#include "ffactory.h"
#include "globals.h"
#include "viewerassetmgr.h"
#include "globals.h"
#include "rendobj.h"
#include "graphicview.h"
#include "datatreeview.h"
#include "mainfrm.h"
#include "distlod.h"
#include "light.h"
#include "camera.h"
#include "w3d_file.h"
#include "wwfile.h"
#include "bmp2d.h"
#include "part_emt.h"
#include "part_ldr.h"
#include "utils.h"
#include "w3derr.h"
#include "chunkio.h"
#include "assetinfo.h"
#include "meshmdl.h"
#include "agg_def.h"
#include "hlod.h"
#include "restrictedfiledialog.h"
#include "viewerscene.h"
#include "ini.h"
#include "ww3d.h"
#include "emitterinstancelist.h"
#include "mesh.h"
#include "screencursor.h"
#include "sphereobj.h"
#include "ringobj.h"
#include "textfile.h"
#include "hmorphanim.h"
#include "mmsystem.h"
#include "soundrobj.h"
#include "dazzle.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CW3DViewDoc

IMPLEMENT_DYNCREATE(CW3DViewDoc, CDocument)

BEGIN_MESSAGE_MAP(CW3DViewDoc, CDocument)
	//{{AFX_MSG_MAP(CW3DViewDoc)
		// NOTE - the ClassWizard will add and remove mapping macros here.
		//    DO NOT EDIT what you see in these blocks of generated code!
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CW3DViewDoc construction/destruction


///////////////////////////////////////////////////////////////
//
//  CW3DViewDoc
//
CW3DViewDoc::CW3DViewDoc (void)
    : m_pCScene (NULL),
      m_pC2DScene (NULL),
		m_pCursorScene (NULL),
      m_pCBackObjectScene (NULL),
		m_pDazzleLayer (NULL),
      m_pCBackObjectCamera (NULL),  
      m_pCBackgroundObject (NULL),
      m_pC2DCamera (NULL),
      m_pCSceneLight (NULL),
      m_pCRenderObj (NULL),
      m_pCAnimation (NULL),
		m_pCAnimCombo (NULL),
		m_pCBackgroundBMP (NULL),		
      m_CurrentFrame (0),
      m_bAnimBlend (TRUE),
		m_bAnimateCamera (false),
		m_bAutoCameraReset (true),
		m_bOneTimeReset (true),
		m_pCursor (NULL),
      m_backgroundColor (0.5F, 0.5F, 0.5F),
		m_ManualFOV (false),
		m_ManualClipPlanes (false),
		m_IsInitialized (false),
		m_bFogEnabled(false),
		m_nChannelQnBytes(2),
		m_bCompress_channel_Q(false)
{
	// Read the camera animation settings from the registry
	m_bAnimateCamera = ((BOOL)theApp.GetProfileInt ("Config", "AnimateCamera", 0)) == TRUE;
	m_bAutoCameraReset = ((BOOL)theApp.GetProfileInt ("Config", "ResetCamera", 1)) == TRUE;
	return ;
}

///////////////////////////////////////////////////////////////
//
//  ~CW3DViewDoc
//
///////////////////////////////////////////////////////////////
CW3DViewDoc::~CW3DViewDoc (void)
{
    CleanupResources ();
	 MEMBER_RELEASE (m_pCursor);
    return ;
}


///////////////////////////////////////////////////////////////
//
//  CleanupResources
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::CleanupResources (void)
{
    if (m_pC2DScene)
    {
		  if (m_pCBackgroundBMP)
        {
            // Remove the background BMP from the scene
				m_pCBackgroundBMP->Remove ();
        }

        // Release the 2D scene we allocated to display background BMPs
        m_pC2DScene->Release_Ref ();
        m_pC2DScene = NULL;
    }

    if (m_pCBackObjectScene)
    {
        if (m_pCBackgroundObject)
        {
            // Remove the background BMP from the scene
				m_pCBackgroundObject->Remove ();
        }

        // Release the scene we allocated to display background objects
        m_pCBackObjectScene->Release_Ref ();
        m_pCBackObjectScene = NULL;
    }

	if (m_pCursor != NULL) {
		m_pCursor->Remove ();		
	}
	MEMBER_RELEASE (m_pCursorScene);

    if (m_pCScene)
    {
        if (m_pCRenderObj)
        {
            // Remove the currently displayed object from the scene
				Remove_Object_From_Scene (m_pCRenderObj);
        }

        if (m_pCSceneLight)
        {
            // Remove the light from the scene
				Remove_Object_From_Scene (m_pCSceneLight);
        }

		  // Get rid of the lined up objects.
		  m_pCScene->Clear_Lineup();

        // Release the scene object we allocated earlier
        m_pCScene->Release_Ref ();
        m_pCScene = NULL;
    }

	 // Was there a dazzle layer?
	 if (m_pDazzleLayer) {
		 delete m_pDazzleLayer;
		 m_pDazzleLayer = NULL;
	 }

    // Was there a valid scene object?
    if (m_pCBackObjectScene)
    {
        // Free the scene object
        m_pCBackObjectScene->Release_Ref ();
        m_pCBackObjectScene = NULL;
    }

    // Was there a valid 2D camera?
    if (m_pC2DCamera)
    {
        // Free the camera object
        m_pC2DCamera->Release_Ref ();
        m_pC2DCamera = NULL;
    }

    // Was there a valid background camera?
    if (m_pCBackObjectCamera)
    {
        // Free the camera object
        m_pCBackObjectCamera->Release_Ref ();
        m_pCBackObjectCamera = NULL;
    }

    // Was there a valid background BMP?
    if (m_pCBackgroundBMP)
    {
        m_pCBackgroundBMP->Release_Ref ();
        m_pCBackgroundBMP = NULL;
    }

    // Was there a valid scene light?
    if (m_pCSceneLight)
    {
        m_pCSceneLight->Release_Ref ();
        m_pCSceneLight = NULL;
    }

    // Was there a valid display object?
    if (m_pCRenderObj)
    {
        // Free the currently displayed object
			SAFE_DELETE (m_pCAnimCombo);
			MEMBER_RELEASE (m_pCAnimation);
			MEMBER_RELEASE (m_pCRenderObj);
    }

    return ;
}

///////////////////////////////////////////////////////////////
//
//  OnNewDocument
//
///////////////////////////////////////////////////////////////
BOOL
CW3DViewDoc::OnNewDocument (void)
{
	if (!CDocument::OnNewDocument())
		return FALSE;
		
	_TheAssetMgr->Start_Tracking_Textures ();
	m_LoadList.Delete_All ();

	 m_bOneTimeReset = true;
    if (m_pCScene && m_pCRenderObj)
    {
        // Remove the currently displayed object from the scene
		  Remove_Object_From_Scene (m_pCRenderObj);
    }

	 if (m_pCScene)
	 {
		 // Remove all objects from the lineup.
		 m_pCScene->Clear_Lineup();

		 // Update the fog color.
		 m_pCScene->Set_Fog_Color(m_backgroundColor);
	 }

    if (m_pCRenderObj)
    {
			// Free the currently displayed object
			SAFE_DELETE (m_pCAnimCombo);
			MEMBER_RELEASE (m_pCAnimation);
			MEMBER_RELEASE (m_pCRenderObj);
    }

    CDataTreeView *pCDataTreeView = GetDataTreeView ();
    if (pCDataTreeView)
    {
        // Delete everything from the tree
        pCDataTreeView->GetTreeCtrl ().DeleteAllItems ();

        // Recreate the root nodes
        pCDataTreeView->CreateRootNodes ();
    }

    // Remove everything from the scene and the asset manager
	 CleanupResources ();
	 //WW3DAssetManager::Get_Instance ()->Release_All_Textures ();
    WW3DAssetManager::Get_Instance ()->Free_Assets ();
	 WW3DAssetManager::Get_Instance ()->Load_Procedural_Textures();

    return TRUE;
}


/////////////////////////////////////////////////////////////////////////////
//
// CW3DViewDoc
//
/////////////////////////////////////////////////////////////////////////////
void
CW3DViewDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		// TODO: add storing code here
	}
	else
	{
		// TODO: add loading code here
	}

	return ;
}

/////////////////////////////////////////////////////////////////////////////
// CW3DViewDoc diagnostics

#ifdef _DEBUG
void CW3DViewDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CW3DViewDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG


///////////////////////////////////////////////////////////////
//
//  InitScene
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::InitScene (void)
{
	if (m_pCScene == NULL) {

		//
		//	Make sure the emitters don't remove themselves from the scene
		// when they are finished emitting...
		//
		ParticleEmitterClass::Set_Default_Remove_On_Complete (false);

		m_pCScene = new ViewerSceneClass;
		ASSERT (m_pCScene);
		if (m_pCScene != NULL) {

			// Set some default ambient lighting
			m_pCScene->Set_Ambient_Light (Vector3 (0.5F, 0.5F, 0.5F));

			// Set up the correct fog color.
			m_pCScene->Set_Fog_Color(GetBackgroundColor());

			// Create a new scene light
			m_pCSceneLight = new LightClass;
			ASSERT (m_pCSceneLight);

			if (m_pCSceneLight != NULL) {

				// Create some default light settings
				m_pCSceneLight->Set_Position (Vector3 (0, 5000, 3000));
				m_pCSceneLight->Set_Intensity (1.0F);
				m_pCSceneLight->Set_Force_Visible(true);
				m_pCSceneLight->Set_Flag (LightClass::NEAR_ATTENUATION, false);
				m_pCSceneLight->Set_Far_Attenuation_Range (1000000, 1000000);
				m_pCSceneLight->Set_Ambient(Vector3(0,0,0));
				m_pCSceneLight->Set_Diffuse (Vector3(1, 1, 1));
				m_pCSceneLight->Set_Specular (Vector3(1, 1, 1));

				// Add this light to the scene
				m_pCScene->Add_Render_Object (m_pCSceneLight);
			}
		}

		// Instantiate a new 2D scene
		m_pC2DScene = new SimpleSceneClass;
		ASSERT (m_pC2DScene);

		// Instantiate a new 2D cursor scene
		m_pCursorScene = new SimpleSceneClass;
		ASSERT (m_pCursorScene);

		Create_Cursor ();
		m_pCursorScene->Add_Render_Object (m_pCursor);


		m_pCBackObjectScene = new SimpleSceneClass;

		// Were we successful in instantiating the scene object?
		ASSERT (m_pCBackObjectScene);
		if (m_pCBackObjectScene) {

			// Set the default ambient light for the background object
			m_pCBackObjectScene->Set_Ambient_Light (Vector3 (0.5F, 0.5F, 0.5F));
		}

			
		// Create a new instance of the camera class to use
		// when rendering the background object
		m_pCBackObjectCamera = new CameraClass ();

		// Were we successful in creating the new instance?
		ASSERT (m_pCBackObjectCamera);
		if (m_pCBackObjectCamera) {

			// Set the default values for the new camera
			m_pCBackObjectCamera->Set_View_Plane (Vector2 (-1.00F, -1.00F), Vector2 (1.00F, 1.00F));
			m_pCBackObjectCamera->Set_Position (Vector3 (0.00F, 0.00F, 0.00F));
			m_pCBackObjectCamera->Set_Clip_Planes (0.1F, 10.0F);
		}        

		// Create a new instance of the camera class to use
		// when rendering the background BMP
		m_pC2DCamera = new CameraClass ();

		// Were we successful in creating the new instance?
		ASSERT (m_pC2DCamera);		
		if (m_pC2DCamera) {

			// Set the default values for the new camera
			m_pC2DCamera->Set_View_Plane (Vector2 (-1.00F, -1.00F), Vector2 (1.00F, 1.00F));
			m_pC2DCamera->Set_Position (Vector3 (0.00F, 0.00F, 1.00F));
			m_pC2DCamera->Set_Clip_Planes (0.1F, 10.0F);
		}

		//
		// Read the texture paths from the registry
		//
		CString path1 = theApp.GetProfileString ("Config", "TexturePath1", "");
		CString path2 = theApp.GetProfileString ("Config", "TexturePath2", "");
		Set_Texture_Path1 (path1);
		Set_Texture_Path2 (path2);	

		// Construct a dazzle layer object 
		m_pDazzleLayer  = new DazzleLayerClass();
		DazzleRenderObjClass::Set_Current_Dazzle_Layer(m_pDazzleLayer);

		// Enable fog if appropriate.
		if (IsFogEnabled()) {
			m_pCScene->Set_Fog_Enable(true);
		}
	}

	Load_Camera_Settings ();
	m_IsInitialized = true;
	return ;
}


///////////////////////////////////////////////////////////////
//
//  OnOpenDocument
//
///////////////////////////////////////////////////////////////
BOOL
CW3DViewDoc::OnOpenDocument (LPCTSTR lpszPathName) 
{
	if (!CDocument::OnOpenDocument(lpszPathName))
		return FALSE;

	//
	//	Don't allow repaints while the load is going on
	//
	CGraphicView *current_view = ::Get_Graphic_View ();
	if (current_view != NULL) {
		current_view->Allow_Update (false);
	}

	//
	// Load the assets from this file into application
	//
	LoadAssetsFromFile (lpszPathName);

	//
	// Re-load the data list to include all new assets
	//
	CDataTreeView *data_view = GetDataTreeView ();
	if (data_view != NULL) {		
		data_view->LoadAssetsIntoTree ();
	}

	//
	//	Turn repainting back on...
	//
	if (current_view != NULL) {
		current_view->Allow_Update (true);
	}

	return TRUE;
}


///////////////////////////////////////////////////////////////
//
//  LoadAssetsFromFile
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::LoadAssetsFromFile (LPCTSTR lpszPathName) 
{
	if (m_pCScene == NULL) {
		InitScene ();
	}

	//
	//	Remember the last path we opened
	//
	m_LastPath = ::Strip_Filename_From_Path (lpszPathName);

	//
	//	Add this path to the load list
	//
	m_LoadList.Add (lpszPathName);
	
	//
	//	Don't allow repaints while the load is going on
	//
	CGraphicView *current_view = ::Get_Graphic_View ();
	if (current_view != NULL) {
		current_view->Allow_Update (false);
	}

	//
	// HACK HACK -- Force the current directory to be the directory
	//              the file is located in.
	//
	if (::strrchr (lpszPathName, '\\')) {
		CString stringTemp = lpszPathName;
		stringTemp = stringTemp.Left ((long)::strrchr (lpszPathName, '\\') - (long)lpszPathName);
		::SetCurrentDirectory (stringTemp);
		_TheSimpleFileFactory->Append_Sub_Directory(stringTemp);
	}

	LPCTSTR extension = ::strrchr (lpszPathName, '.');
	if (::lstrcmpi (extension, ".tga") == 0 || ::lstrcmpi (extension, ".dds") == 0) {
		
		// Load the texture file into the asset manager
		TextureClass *ptexture = WW3DAssetManager::Get_Instance()->Get_Texture (::Get_Filename_From_Path (lpszPathName));
		if (ptexture != NULL) {
			ptexture->Release_Ref();
		}

	} else {
		WW3DAssetManager::Get_Instance()->Load_3D_Assets (::Get_Filename_From_Path (lpszPathName));
	}

	//
	//	Turn repainting back on...
	//
	if (current_view != NULL) {
		current_view->Allow_Update (true);
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  Reload_Displayed_Object
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Reload_Displayed_Object (void)
{
	GetDataTreeView ()->Display_Asset ();
	//SAFE_ADD_REF (m_pCRenderObj);
	//DisplayObject (m_pCRenderObj, false, false);
	//SAFE_RELEASE_REF (m_pCRenderObj);
	return ;
}


///////////////////////////////////////////////////////////////
//
//  Display_Emitter
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Display_Emitter
(
	ParticleEmitterClass *pemitter,
	bool use_global_reset_flag,
	bool allow_reset
)
{
	ASSERT (m_pCScene);

	// Data OK?
	if (m_pCScene != NULL) {

		// Lose the animation
		SAFE_DELETE (m_pCAnimCombo);
		MEMBER_RELEASE (m_pCAnimation);

			if (m_pCRenderObj != NULL) {
				
				// Remove this object from the scene
				Remove_Object_From_Scene (m_pCRenderObj);
				m_pCRenderObj->Release_Ref ();
				m_pCRenderObj = NULL;
			}
			m_pCScene->Clear_Lineup();

		// Do we have a new emitter to display?
		if (pemitter != NULL) {

			// Add the emitter to the scene
			pemitter->Set_Transform (Matrix3D (1));			
			MEMBER_ADD (m_pCRenderObj, pemitter);
			m_pCScene->Add_Render_Object (m_pCRenderObj);
			pemitter->Start ();

			CGraphicView *pCGraphicView = GetGraphicView ();
			if (pCGraphicView) {

				// Try to find a good view for the emitter
				if ((use_global_reset_flag && m_bAutoCameraReset) ||
					 ((use_global_reset_flag == false) && allow_reset) ||
					 m_bOneTimeReset) {
					pCGraphicView->Reset_Camera_To_Display_Emitter (*pemitter);
					m_bOneTimeReset = false;
				}
			}
		}
	}
	
	return ;
}


///////////////////////////////////////////////////////////////
//
//  DisplayObject
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::DisplayObject
(
	RenderObjClass *pCModel,
	bool use_global_reset_flag,
	bool allow_reset,
	bool add_ghost
)
{
    ASSERT (m_pCScene);

    // Data OK?
    if (m_pCScene)
    {
        // Lose the animation
		  SAFE_DELETE (m_pCAnimCombo);
		  MEMBER_RELEASE (m_pCAnimation);

        // Do we have an old object to remove from the scene?
		  if (add_ghost == false) {
			  if (m_pCRenderObj)
			  {
					// Remove this object from the scene
					Remove_Object_From_Scene (m_pCRenderObj);
					m_pCRenderObj->Release_Ref ();
					m_pCRenderObj = NULL;
			  }
		  }
		  m_pCScene->Clear_Lineup();

        // Do we have a new object to display?
        if (pCModel && (add_ghost == false))
        {
            // Reset the animation for this object
            pCModel->Set_Animation ();

            m_pCRenderObj = pCModel;
            m_pCRenderObj->Add_Ref ();
            m_pCRenderObj->Set_Transform (Matrix3D (1));

            // Add this object to the scene
				if (m_pCRenderObj->Class_ID () == RenderObjClass::CLASSID_BITMAP2D) {
					m_pC2DScene->Add_Render_Object (m_pCRenderObj);
				} else {
					m_pCScene->Add_Render_Object (m_pCRenderObj);
				}

				// Reset the current lod to be the lowest possible LOD...
				if ((m_pCScene->Are_LODs_Switching ()) &&
					 (m_pCRenderObj->Class_ID () == RenderObjClass::CLASSID_HLOD)) {
					((HLodClass *)m_pCRenderObj)->Set_LOD_Level (0);
				}

            CGraphicView *pCGraphicView = GetGraphicView ();
            if (pCGraphicView)
            {
                // Reset the camera to so the user can see
                // the whole object
                if ((use_global_reset_flag && m_bAutoCameraReset) ||
					     ((use_global_reset_flag == false) && allow_reset) ||
						  m_bOneTimeReset) {
						pCGraphicView->Reset_Camera_To_Display_Object (*m_pCRenderObj);
						m_bOneTimeReset = false;
					 }
            }
        }
		  else if (pCModel) {
            // Reset the animation for this object
            pCModel->Set_Animation ();

				RenderObjClass *m_pCRenderObj;

            m_pCRenderObj = pCModel;
            m_pCRenderObj->Add_Ref ();
            m_pCRenderObj->Set_Transform (Matrix3D (1));

            // Add this object to the scene
				if (m_pCRenderObj->Class_ID () == RenderObjClass::CLASSID_BITMAP2D) {
					m_pC2DScene->Add_Render_Object (m_pCRenderObj);
				} else {
					m_pCScene->Clear_Lineup();
					m_pCScene->Add_Render_Object (m_pCRenderObj);
				}

				// Reset the current lod to be the lowest possible LOD...
				if ((m_pCScene->Are_LODs_Switching ()) &&
					 (m_pCRenderObj->Class_ID () == RenderObjClass::CLASSID_HLOD)) {
					((HLodClass *)m_pCRenderObj)->Set_LOD_Level (0);
				}

            CGraphicView *pCGraphicView = GetGraphicView ();
            if (pCGraphicView)
            {
                // Reset the camera to so the user can see
                // the whole object
                if ((use_global_reset_flag && m_bAutoCameraReset) ||
					     ((use_global_reset_flag == false) && allow_reset) ||
						  m_bOneTimeReset) {
						pCGraphicView->Reset_Camera_To_Display_Object (*m_pCRenderObj);
						m_bOneTimeReset = false;
					 }
            }
		  }
    }

    return ;
}


///////////////////////////////////////////////////////////////
//
//  ResetAnimation
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::ResetAnimation (void)
{
	if (m_pCAnimation != NULL) {
		
		//
		// Reset the frame counter
		//
		m_CurrentFrame = 0;
		m_animTime = 0.00F;

		float frame_rate = m_pCAnimation->Get_Frame_Rate ();
		float anim_speed = ::Get_Graphic_View ()->GetAnimationSpeed ();

		//
		// Update the status bar on the main window
		//
		((CMainFrame *)::AfxGetMainWnd ())->UpdateFrameCount (	0,
																					m_pCAnimation->Get_Num_Frames () - 1,
																					frame_rate * anim_speed);
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  StepAnimation
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::StepAnimation (int iFrameInc)
{
	if (m_pCRenderObj && m_pCAnimation) {
		int iTotalFrames = m_pCAnimation->Get_Num_Frames ();

		// Increment the frame
		m_CurrentFrame += iFrameInc;

		//
		// Wrap the animation
		//
		if (m_CurrentFrame >= iTotalFrames) {
			m_CurrentFrame = 0;
			m_animTime = 0.00F;
		}
		else if (m_CurrentFrame < 0) {
			m_CurrentFrame = iTotalFrames-1;
		}

		//
		// Update the status bar on the main window
		//
		float frame_rate = m_pCAnimation->Get_Frame_Rate ();
		float anim_speed = ::Get_Graphic_View ()->GetAnimationSpeed ();
		((CMainFrame *)::AfxGetMainWnd ())->UpdateFrameCount (m_CurrentFrame, iTotalFrames - 1, frame_rate * anim_speed);

		//
		// Update the animation frame
		//
		if (m_pCAnimCombo) {
			for (int i = 0; i < m_pCAnimCombo->Get_Num_Anims(); i++)
			{
			m_pCAnimCombo->Set_Frame(i, m_CurrentFrame);
			}

			m_pCRenderObj->Set_Animation (m_pCAnimCombo);
		} else {
			m_pCRenderObj->Set_Animation (m_pCAnimation, m_CurrentFrame);
		}

		Update_Camera ();
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  PlayAnimation
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::PlayAnimation
(
    RenderObjClass *pCModel,
    LPCTSTR pszAnimationName,
	 bool use_global_reset_flag,
	 bool allow_reset
)
{
    ASSERT (m_pCScene);
    ASSERT (pCModel);
    ASSERT (pszAnimationName);

    // Data OK?
    if (m_pCScene &&
        pCModel &&
        pszAnimationName)
    {
        // Display this hierarchy on the screen
        DisplayObject (pCModel);

        // Get an instance of the animation object
		  SAFE_DELETE (m_pCAnimCombo);
		  MEMBER_RELEASE (m_pCAnimation);
        m_pCAnimation = WW3DAssetManager::Get_Instance()->Get_HAnim (pszAnimationName);       
        ASSERT (m_pCAnimation);

        // Reset the frame counter
        m_CurrentFrame = 0;
        m_animTime = 0.00F;

        if (m_pCRenderObj)
        {
            // Update the animation frame
            m_pCRenderObj->Set_Animation (m_pCAnimation, 0);

            CGraphicView *pCGraphicView = GetGraphicView ();
            if (pCGraphicView)
            {
                // Reset the camera to so the user can see
                // the whole object
                if ((use_global_reset_flag && m_bAutoCameraReset) ||
					     ((use_global_reset_flag == false) && allow_reset) ||
						  m_bOneTimeReset) {
						pCGraphicView->Reset_Camera_To_Display_Object (*m_pCRenderObj);
						m_bOneTimeReset = false;
					 }

                AfxGetMainWnd ()->PostMessage (WM_COMMAND, MAKELPARAM (IDM_ANI_START, 0));
            }
        }

		  Update_Camera ();
		  Play_Animation_Sound ();
    }
        
    return ;
}


///////////////////////////////////////////////////////////////
//
//	Play_Animation_Sound
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Play_Animation_Sound (void)
{
	if (m_pCAnimation != NULL) {	  
	  CString animation_name = m_pCAnimation->Get_Name ();

	  //
	  // Play a sound with the animation
	  //
	  const char *separator = ::strchr (animation_name , '.');
	  if (separator != NULL) {
		  CString sound_filename = separator + 1;
		  sound_filename += ".wav";
		  ::PlaySound (NULL, NULL, SND_PURGE);
		  ::PlaySound (sound_filename, NULL, SND_FILENAME | SND_ASYNC | SND_NODEFAULT);
		}
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//	PlayAnimation
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::PlayAnimation
(
    RenderObjClass *pCModel,
    HAnimComboClass *pCAnimCombo,
	 bool use_global_reset_flag,
	 bool allow_reset
)
{
    ASSERT (m_pCScene);
    ASSERT (pCModel);
    ASSERT (pCAnimCombo);

    // Data OK?
    if (m_pCScene &&
        pCModel &&
        pCAnimCombo)
    {
        // Display this hierarchy on the screen
        DisplayObject (pCModel);

        // Get an instance of the animation object
		  SAFE_DELETE (m_pCAnimCombo);
		  MEMBER_RELEASE (m_pCAnimation);
		  m_pCAnimCombo = pCAnimCombo;
		  m_pCAnimation = m_pCAnimCombo->Get_Motion(0);	// ref added by get_motion
        ASSERT (m_pCAnimation);

		  // It will be assumed that every animation in the m_pCAnimCombo
		  // has the same number of frames and has the same framerate as
		  // the first animation in the combo (m_pCAnimation).

        // Reset the frame counter
        m_CurrentFrame = 0;
        m_animTime = 0.00F;

        if (m_pCRenderObj)
        {
            // Update the animation frame
			  for (int i = 0; i < m_pCAnimCombo->Get_Num_Anims(); i++)
				  m_pCAnimCombo->Set_Frame(i, 0.0f);
            m_pCRenderObj->Set_Animation(m_pCAnimCombo);

            CGraphicView *pCGraphicView = GetGraphicView ();
            if (pCGraphicView)
            {
                // Reset the camera to so the user can see
                // the whole object
                if ((use_global_reset_flag && m_bAutoCameraReset) ||
					     ((use_global_reset_flag == false) && allow_reset) ||
						  m_bOneTimeReset) {
						pCGraphicView->Reset_Camera_To_Display_Object (*m_pCRenderObj);
						m_bOneTimeReset = false;
					 }

                AfxGetMainWnd ()->PostMessage (WM_COMMAND, MAKELPARAM (IDM_ANI_START, 0));
            }
        }

		  Update_Camera ();
		  Play_Animation_Sound ();
    }
        
    return ;
}


////////////////////////////////////////////////////////////////////////////
//
//  Get_Camera_Transform
//
////////////////////////////////////////////////////////////////////////////
bool
Get_Camera_Transform (RenderObjClass *render_obj, Matrix3D &tm) 
{
	bool retval = false;

	if (render_obj != NULL) {
		for (int index = 0; (index < render_obj->Get_Num_Sub_Objects ()) && !retval; index ++) {
			RenderObjClass *psub_obj = render_obj->Get_Sub_Object (index);
			if (psub_obj != NULL) {
				retval = Get_Camera_Transform (psub_obj, tm);
			}
			MEMBER_RELEASE (psub_obj);
		}

		if (!retval) {
			int index = render_obj->Get_Bone_Index ("CAMERA");
			if (index > 0) {
				tm = render_obj->Get_Bone_Transform (index);
				retval = true;
			}
		}
	}

	return retval;
}


///////////////////////////////////////////////////////////////
//
//  Update_Camera
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Update_Camera (void)
{
	// Should we update the camera's position as well?
	if (m_bAnimateCamera && m_pCRenderObj != NULL) {			

		Matrix3D transform (1);
		if (Get_Camera_Transform (m_pCRenderObj, transform)) {

			// Convert the bone's transform into a camera transform
			//Matrix3D	transform = m_pCRenderObj->Get_Bone_Transform (index);												
			Matrix3D cam_transform (Vector3 (0, -1, 0), Vector3 (0, 0, 1), Vector3 (-1, 0, 0), Vector3 (0, 0, 0));
			Matrix3D new_transform = transform * cam_transform;

			// Pass the new transform onto the camera
			CameraClass *pcamera = GetGraphicView()->GetCamera ();
			pcamera->Set_Transform (new_transform);
		}
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  UpdateFrame
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::UpdateFrame (float relativeTimeSlice)
{
	if (m_pCRenderObj && m_pCAnimation) {

		int total_frames = m_pCAnimation->Get_Num_Frames ();
		float frame_rate = m_pCAnimation->Get_Frame_Rate ();
		float loop_time = ((float)(total_frames-1)) / frame_rate;

		//
		// Update the total elapsed animation time
		//
		m_animTime += relativeTimeSlice;        		  
		if (m_animTime > loop_time) {
			m_animTime -= loop_time;
		}

		// Adjust the current frame counter
		m_CurrentFrame = (frame_rate * m_animTime);

		//
		// Update the status bar on the main window
		//
		float anim_speed = ::Get_Graphic_View ()->GetAnimationSpeed ();
		((CMainFrame *)::AfxGetMainWnd ())->UpdateFrameCount (m_CurrentFrame, total_frames - 1, frame_rate * anim_speed);

		if (m_pCAnimCombo) {

			//
			// Update the animation frame for all anims in the combo.
			//
			for (int i = 0; i < m_pCAnimCombo->Get_Num_Anims(); i++) {
				m_pCAnimCombo->Set_Frame(i, m_CurrentFrame);
			}

			m_pCRenderObj->Set_Animation (m_pCAnimCombo);
		} else if (m_bAnimBlend) {
			m_pCRenderObj->Set_Animation (m_pCAnimation, m_CurrentFrame);
		} else {
			m_pCRenderObj->Set_Animation (m_pCAnimation, (int)m_CurrentFrame);
		}

		Update_Camera ();
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  GetDataTreeView
//
///////////////////////////////////////////////////////////////
CDataTreeView *
CW3DViewDoc::GetDataTreeView (void)
{
    CDataTreeView *pCDataTreeView = NULL;

    // Get a pointer to the main window
    CMainFrame *pCMainWnd = (CMainFrame *)::AfxGetMainWnd ();
    if (pCMainWnd)
    {
        // Get the pane from the main window
        pCDataTreeView = (CDataTreeView *)pCMainWnd->GetPane (0, 0);
    }

    // Return a pointer to the tree view
    return pCDataTreeView;
}


///////////////////////////////////////////////////////////////
//
//  GetGraphicView
//
///////////////////////////////////////////////////////////////
CGraphicView *
CW3DViewDoc::GetGraphicView (void)
{
    CGraphicView *pCGrephicView = NULL;

    // Get a pointer to the main window
    CMainFrame *pCMainWnd = (CMainFrame *)::AfxGetMainWnd ();
    if (pCMainWnd)
    {
        // Get the pane from the main window
        pCGrephicView = (CGraphicView *)pCMainWnd->GetPane (0, 1);
    }

    // Return a pointer to the graphic view
    return pCGrephicView;
}


///////////////////////////////////////////////////////////////
//
//  GenerateLOD
//
///////////////////////////////////////////////////////////////
HLodPrototypeClass *
CW3DViewDoc::GenerateLOD
(
	LPCTSTR pszLODBaseName,
	LOD_NAMING_TYPE type
)
{
	// Assume failure
	HLodPrototypeClass *plod_prototype = NULL;

	// Get an iterator from the asset manager that we can
	// use to enumerate the currently loaded assets
	RenderObjIterator *pObjEnum = WW3DAssetManager::Get_Instance()->Create_Render_Obj_Iterator ();    
	ASSERT (pObjEnum);
	if (pObjEnum)
	{
		int lod_count = 0;
		int iStartingIndex = 0xFFFF;
		char starting_char = 'Z';

		// Loop through all the assets in the manager looking for hierarchies that match the
		// naming convention
		for (pObjEnum->First ();
			  pObjEnum->Is_Done () == FALSE;
			  pObjEnum->Next ())	{
			LPCTSTR pszItemName = pObjEnum->Current_Item_Name ();

			// Is this a hierarchy?
			if (WW3DAssetManager::Get_Instance()->Render_Obj_Exists (pszItemName) &&
				 (pObjEnum->Current_Item_Class_ID () == RenderObjClass::CLASSID_HLOD)) {

				if (Is_Model_Part_of_LOD (pszItemName, pszLODBaseName, type)) {
					lod_count ++;
					if (type == TYPE_COMMANDO) {
						iStartingIndex = min (iStartingIndex, ::atoi (&pszItemName[::lstrlen (pszItemName)-1]));
					} else {
						starting_char = min (starting_char, (char)::toupper (pszItemName[::lstrlen (pszItemName)-1]));
					}
				}
			}
		}

		// Create an array of LOD models
		RenderObjClass **plod_array = new RenderObjClass *[lod_count];
		ASSERT (plod_array != NULL);
		if (plod_array != NULL) {

			// Loop through all the levels-of-detail and add them to our array
			for (int lod_index = 0; lod_index < lod_count; lod_index ++) {
				CString lod_name;

				if (type == TYPE_COMMANDO) {
					lod_name.Format ("%sL%d", pszLODBaseName, iStartingIndex + lod_index);
				} else {
					lod_name.Format ("%s%c", pszLODBaseName, starting_char++);
				}

				// Add this lod to the array in reverse order (LOD 0 is the lowest-level LOD)
				plod_array[lod_count - (lod_index+1)] = WW3DAssetManager::Get_Instance ()->Create_Render_Obj (lod_name);
			}

			// Create a new HLod prototype from the provided lod array
			HLodClass *pnew_lod = new HLodClass (pszLODBaseName, plod_array, lod_count);
			HLodDefClass *pdefinition = new HLodDefClass (*pnew_lod);
			plod_prototype = new HLodPrototypeClass (pdefinition);

			MEMBER_RELEASE (pnew_lod);

			// Loop through all the LOD definitions and free their names
			for (lod_index = 0; lod_index < lod_count; lod_index ++) {
				MEMBER_RELEASE (plod_array[lod_index]);
			}

			// Free the LOD definition array
			SAFE_DELETE_ARRAY (plod_array);
		}

		SAFE_DELETE (pObjEnum);
	}

	// Return the LOD prototype to the caller
	return plod_prototype;
}


///////////////////////////////////////////////////////////////
//
//  SetBackgroundBMP
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::SetBackgroundBMP (LPCTSTR pszBackgroundBMP)
{
    ASSERT (m_pC2DScene);
    if (m_pC2DScene)
    {
		  // Remove the old background BMP if there was one.
        if (m_pCBackgroundBMP)
        {
            // Remove the background BMP from the scene
            // and release its pointer
				m_pCBackgroundBMP->Remove ();
            m_pCBackgroundBMP->Release_Ref ();
            m_pCBackgroundBMP = NULL;
        }

        // Is this a new background BMP?
        if (pszBackgroundBMP &&
            (m_stringBackgroundBMP.CompareNoCase (pszBackgroundBMP) != 0))
        {
				// Create a new instance of the BMP object to use
            m_pCBackgroundBMP = new Bitmap2DObjClass (pszBackgroundBMP, 0.5F, 0.5F, TRUE, FALSE);
				        
            // Were we successful in creating the bitmap object?
            ASSERT (m_pCBackgroundBMP);
            if (m_pCBackgroundBMP)
            {
                // Add the object to the scene
					 m_pC2DScene->Add_Render_Object (m_pCBackgroundBMP);
            }
        }

        // Remember what our current background BMP is
        m_stringBackgroundBMP = pszBackgroundBMP;
    }

    return ;
}


///////////////////////////////////////////////////////////////
//
//  LoadSettings
//
///////////////////////////////////////////////////////////////
BOOL
CW3DViewDoc::LoadSettings (LPCTSTR filename)
{
	// Assume failure
	BOOL bReturn = FALSE;

	// Params OK?
	ASSERT (filename != NULL);
	if (filename != NULL) {

		// Open the INI file
		FileClass * pini_file = _TheFileFactory->Get_File (filename);
		INIClass ini_obj (*pini_file);			
		
		CGraphicView *graphic_view = GetGraphicView ();
		Vector3 color;

		//
		// Ambient light color
		//
		if (ini_obj.Is_Present ("Settings", "AmbientLightR") &&
			 ini_obj.Is_Present ("Settings", "AmbientLightG") &&
			 ini_obj.Is_Present ("Settings", "AmbientLightB")) {
			
			// Read the settings from,the INI file
			color.X = ini_obj.Get_Float ("Settings", "AmbientLightR");
			color.Y = ini_obj.Get_Float ("Settings", "AmbientLightG");
			color.Z = ini_obj.Get_Float ("Settings", "AmbientLightB");

			// Pass the ambient light color onto the scene
			m_pCScene->Set_Ambient_Light (color);
		}

		//
		// Scene light color
		//
		if (ini_obj.Is_Present ("Settings", "SceneLightR") &&
			 ini_obj.Is_Present ("Settings", "SceneLightG") &&
			 ini_obj.Is_Present ("Settings", "SceneLightB")) {
			
			// Read the settings from,the INI file
			color.X = ini_obj.Get_Float ("Settings", "SceneLightR");
			color.Y = ini_obj.Get_Float ("Settings", "SceneLightG");
			color.Z = ini_obj.Get_Float ("Settings", "SceneLightB");

			// Pass the scene light color onto the light
         m_pCSceneLight->Set_Diffuse (color);
         m_pCSceneLight->Set_Specular (color);
		}

		//
		// Scene light orientation
		//
		if (ini_obj.Is_Present ("Settings", "SceneLightX") &&
			 ini_obj.Is_Present ("Settings", "SceneLightY") &&
			 ini_obj.Is_Present ("Settings", "SceneLightZ") &&
			 ini_obj.Is_Present ("Settings", "SceneLightW")) {
			
			// Read the settings from,the INI file
			Quaternion orientation;
			orientation.X = ini_obj.Get_Float ("Settings", "SceneLightX");
			orientation.Y = ini_obj.Get_Float ("Settings", "SceneLightY");
			orientation.Z = ini_obj.Get_Float ("Settings", "SceneLightZ");
			orientation.W = ini_obj.Get_Float ("Settings", "SceneLightW");

			// Get the light's transform and inverse transform			
			Vector3 obj_pos = graphic_view->Get_Object_Center ();
			Vector3 light_pos = m_pCSceneLight->Get_Position ();
			float distance = (light_pos - obj_pos).Length ();

			// Move the light to the object's center, perform the rotation, and
			Matrix3D light_tm (1);
			light_tm.Set_Translation (obj_pos);
			Matrix3D::Multiply (light_tm, Build_Matrix3D (orientation), &light_tm);
			light_tm.Translate (Vector3 (0, 0, distance));
			
			// Pass the new transform onto the light
			RenderObjClass *pLightMesh = graphic_view->Get_Light_Mesh ();
			pLightMesh->Set_Transform (light_tm);
			m_pCSceneLight->Set_Transform (light_tm);
		}

		//
		// Scene light distance, intensity, and attenuation
		//
		if (ini_obj.Is_Present ("Settings", "SceneLightDistance") &&
			 ini_obj.Is_Present ("Settings", "SceneLightIntensity") &&
			 ini_obj.Is_Present ("Settings", "SceneLightAttenStart") &&
			 ini_obj.Is_Present ("Settings", "SceneLightAttenEnd") &&
			 ini_obj.Is_Present ("Settings", "SceneLightAttenOn")) {

			// Read the settings from,the INI file
			float distance = ini_obj.Get_Float ("Settings", "SceneLightDistance");
			float intensity = ini_obj.Get_Float ("Settings", "SceneLightIntensity");
			float start = ini_obj.Get_Float ("Settings", "SceneLightAttenStart");
			float end = ini_obj.Get_Float ("Settings", "SceneLightAttenEnd");
			int atten_on = ini_obj.Get_Int ("Settings", "SceneLightAttenOn");
			
			// Pass the intensity and attenuation settings onto the light
			m_pCSceneLight->Set_Intensity (intensity);
			m_pCSceneLight->Set_Far_Attenuation_Range (start, end);
			m_pCSceneLight->Set_Flag (LightClass::FAR_ATTENUATION, (atten_on == 1));

			// Get the position of the light and the displayed object
			Vector3 obj_pos = graphic_view->Get_Object_Center ();
			Vector3 light_pos = m_pCSceneLight->Get_Position ();			
			Vector3 new_pos = (light_pos - obj_pos);
			new_pos.Normalize ();
			new_pos = new_pos * distance;

			// Pass the new position onto the light
			RenderObjClass *pLightMesh = graphic_view->Get_Light_Mesh ();
			pLightMesh->Set_Position (new_pos);
			m_pCSceneLight->Set_Position (new_pos);			
		}

		//
		// Background color
		//
		if (ini_obj.Is_Present ("Settings", "BackgroundR") &&
			 ini_obj.Is_Present ("Settings", "BackgroundG") &&
			 ini_obj.Is_Present ("Settings", "BackgroundB")) {
			
			// Read the settings from,the INI file
			color.X = ini_obj.Get_Float ("Settings", "BackgroundR");
			color.Y = ini_obj.Get_Float ("Settings", "BackgroundG");
			color.Z = ini_obj.Get_Float ("Settings", "BackgroundB");

			// Record the background color for later use
			SetBackgroundColor (color);
		} 

		//
		// Background bitmap
		//
		if (ini_obj.Is_Present ("Settings", "BackgroundBMP")) {
			
			// Load this background BMP
			TCHAR bmp_filename[MAX_PATH];
			ini_obj.Get_String ("Settings", "BackgroundBMP", "", bmp_filename, sizeof (bmp_filename));
			SetBackgroundBMP (bmp_filename);
		}

		//
		// Fog Settings
		//
		if (ini_obj.Is_Present ("Settings", "FogEnabled")) {
			bool enable = ini_obj.Get_Bool ("Settings", "FogEnabled");
			EnableFog(enable);
		}

      // Close the INI file
		_TheFileFactory->Return_File (pini_file);
	}

	// Return the TRUE/FALSE result code
	return bReturn;
}


///////////////////////////////////////////////////////////////
//
//  SaveSettings
//
///////////////////////////////////////////////////////////////
BOOL
CW3DViewDoc::SaveSettings
(
    LPCTSTR pszFilename,
    DWORD dwSettingsMask
)
{
    // Assume failure
    BOOL bReturn = FALSE;
    ASSERT (pszFilename);
    ASSERT (dwSettingsMask != 0L);
    ASSERT (m_pCScene);    

    // Is the filename OK?
    HANDLE hFile = ::CreateFile (pszFilename,
                                 0,
                                 0,
                                 NULL,
                                 OPEN_ALWAYS,
                                 0L,
                                 NULL);

    ASSERT (hFile != NULL);
    if (hFile == NULL)
    {
        // Invalid file, let the user know
        ::AfxGetMainWnd ()->MessageBox ("Unable to open file for writing.  Please select another filename.", "File Error", MB_ICONERROR | MB_OK);
    }
    else if (pszFilename &&
             (dwSettingsMask != 0L) &&
             (m_pCScene != NULL))
    {
        CString stringCompleteFilename = pszFilename;

        // Does this filename contain a path?
        if (::strrchr (pszFilename, '\\') == NULL)
        {
            // Add the current directories path to the filename
            TCHAR szPath[MAX_PATH] = { 0 };
            ::GetCurrentDirectory (sizeof (szPath), szPath);

            if (szPath[::lstrlen (szPath)-1] != '\\')
            {
                // Ensure the path is directory delimited
                ::strcat (szPath, "\\");
            }

            // Prepend the filename with its new path
            stringCompleteFilename = CString (szPath) + stringCompleteFilename;
        }

        // Should we save light settings?
        if (dwSettingsMask & SAVE_SETTINGS_LIGHT)
        {
            Vector3 colorSettings = m_pCScene->Get_Ambient_Light ();
        
            // Write the 'Red' component out to the file
            CString stringValue;
            stringValue.Format ("%f", colorSettings.X);
            ::WritePrivateProfileString ("Settings",
                                         "AmbientLightR",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the 'Green' component out to the file
            stringValue.Format ("%f", colorSettings.Y);
            ::WritePrivateProfileString ("Settings",
                                         "AmbientLightG",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the 'Blue' component out to the file
            stringValue.Format ("%f", colorSettings.Z);
            ::WritePrivateProfileString ("Settings",
                                         "AmbientLightB",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

             m_pCSceneLight->Get_Diffuse (&colorSettings);
        
            // Write the 'Red' component out to the file
            stringValue.Format ("%f", colorSettings.X);
            ::WritePrivateProfileString ("Settings",
                                         "SceneLightR",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the 'Green' component out to the file
            stringValue.Format ("%f", colorSettings.Y);
            ::WritePrivateProfileString ("Settings",
                                         "SceneLightG",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the 'Blue' component out to the file
            stringValue.Format ("%f", colorSettings.Z);
            ::WritePrivateProfileString ("Settings",
                                         "SceneLightB",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

				Matrix3D transform = m_pCSceneLight->Get_Transform ();
				Quaternion orientation = ::Build_Quaternion (transform);
        
            // Write the x-position out to the file
            stringValue.Format ("%f", orientation.X);
            ::WritePrivateProfileString ("Settings",
                                         "SceneLightX",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the y-position out to the file
            stringValue.Format ("%f", orientation.Y);
            ::WritePrivateProfileString ("Settings",
                                         "SceneLightY",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the z-position out to the file
            stringValue.Format ("%f", orientation.Z);
            ::WritePrivateProfileString ("Settings",
                                         "SceneLightZ",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the w-position out to the file
            stringValue.Format ("%f", orientation.W);
            ::WritePrivateProfileString ("Settings",
                                         "SceneLightW",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

				// Get the light's transform and inverse transform
				CGraphicView *pCGraphicView = GetGraphicView ();
				Vector3 obj_pos = pCGraphicView->Get_Object_Center ();
				Vector3 light_pos = m_pCSceneLight->Get_Position ();
				float distance = (light_pos - obj_pos).Length ();
        
            // Write the distance out to the file
            stringValue.Format ("%f", distance);
            ::WritePrivateProfileString ("Settings",
                                         "SceneLightDistance",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the intensity out to the file
				float intensity = m_pCSceneLight->Get_Intensity ();
            stringValue.Format ("%f", intensity);
            ::WritePrivateProfileString ("Settings",
                                         "SceneLightIntensity",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the start attenuation out to the file
				double start = 0;
				double end = 0;
				m_pCSceneLight->Get_Far_Attenuation_Range (start, end);
            stringValue.Format ("%f", start);
            ::WritePrivateProfileString ("Settings",
                                         "SceneLightAttenStart",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the end attenuation out to the file
            stringValue.Format ("%f", end);
            ::WritePrivateProfileString ("Settings",
                                         "SceneLightAttenEnd",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the end attenuation out to the file
				BOOL atten_on = m_pCSceneLight->Get_Flag (LightClass::FAR_ATTENUATION);
				stringValue.Format ("%d", atten_on);
            ::WritePrivateProfileString ("Settings",
													  "SceneLightAttenOn",
													  stringValue,
													  (LPCTSTR)stringCompleteFilename);
        }

        // Should we save background settings?
        if (dwSettingsMask & SAVE_SETTINGS_BACK)
        {
            // Write the 'Red' component out to the file
            CString stringValue;
            stringValue.Format ("%f", m_backgroundColor.X);
            ::WritePrivateProfileString ("Settings",
                                         "BackgroundR",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the 'Green' component out to the file
            stringValue.Format ("%f", m_backgroundColor.Y);
            ::WritePrivateProfileString ("Settings",
                                         "BackgroundG",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the 'Blue' component out to the file
            stringValue.Format ("%f", m_backgroundColor.Z);
            ::WritePrivateProfileString ("Settings",
                                         "BackgroundB",
                                         stringValue,
                                         (LPCTSTR)stringCompleteFilename);

            // Write the BMP filename out to the profile
            ::WritePrivateProfileString ("Settings",
                                         "BackgroundBMP",
                                         (LPCTSTR)m_stringBackgroundBMP,
                                         (LPCTSTR)stringCompleteFilename);

				// Write the fog settings out to the file.
				::WritePrivateProfileString("Settings",
													 "FogEnabled",
													 IsFogEnabled() ? "true" : "false",
													 (LPCTSTR)stringCompleteFilename);
        }

        // Should we save camera settings?
        if (dwSettingsMask & SAVE_SETTINGS_CAMERA)
        {
        }

        // Success!
        bReturn = TRUE;
    }
    
    // Return the TRUE/FALSE result code
    return bReturn;
}


///////////////////////////////////////////////////////////////
//
//  Save_Selected_LOD
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Save_Selected_LOD (void)
{
	// Assume failure
	bool retval = false;

	// Is this an emitter?
	if ((m_pCRenderObj != NULL) &&
		 m_pCRenderObj->Class_ID () == RenderObjClass::CLASSID_HLOD) {
		
		// Build the default filename from the name of the LOD
		CString default_filename = GetDataTreeView ()->GetCurrentSelectionName ();
		default_filename += ".w3d";

		RestrictedFileDialogClass dialog (FALSE,
												  ".w3d",
												  (LPCTSTR)default_filename,
												  OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_EXPLORER,
												  "Westwood 3D Files (*.w3d)|*.~xyzabc||",
												  AfxGetMainWnd ());

		// Ask the user what filename they wish to save as.
		dialog.m_ofn.lpstrTitle = "Export LOD";
		if (dialog.DoModal () == IDOK) {
			
			// Save the LOD to the requested file
			retval = Save_Current_LOD (dialog.GetPathName ());
		}
	}

	// Return the true/false result code
	return retval;
}


///////////////////////////////////////////////////////////////
//
//  Save_Current_LOD
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Save_Current_LOD (const CString &filename)
{
	// Assume failure
	bool retval = false;

	// Get the prototype for this aggregate
	HLodPrototypeClass *proto = NULL;
	proto = (HLodPrototypeClass *)WW3DAssetManager::Get_Instance ()->Find_Prototype (m_pCRenderObj->Get_Name ());
	ASSERT (proto != NULL);
	if (proto != NULL) {

		// Get the definition from the prototype
		HLodDefClass *pdefinition = proto->Get_Definition ();
		ASSERT (pdefinition != NULL);
		if (pdefinition != NULL) {

			// Get a file object for the new file
			FileClass *pfile = _TheFileFactory->Get_File (filename);
			if (pfile) {

				// Open the file for writing
				pfile->Open (FileClass::WRITE);

				// Save the definition to the file
				ChunkSaveClass save_chunk (pfile);
				retval = (pdefinition->Save (save_chunk) == WW3D_ERROR_OK);

				// Close the file
				pfile->Close ();
				_TheFileFactory->Return_File (pfile);
			}
		}
	}

	// Return the true/false result code
	return retval;


}


///////////////////////////////////////////////////////////////
//
//  SetBackgroundObject
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::SetBackgroundObject (LPCTSTR pszBackgroundObjectName)
{
    // State valid?
    ASSERT (m_pCBackObjectScene);
    ASSERT (m_pCBackObjectCamera);
    if (m_pCBackObjectScene && m_pCBackObjectCamera)
    {
        // Did we have an old background object we needed to remove?
        if (m_pCBackgroundObject)
        {
            // Remove the object from the scene
				m_pCBackgroundObject->Remove ();

            // Free the object
            m_pCBackgroundObject->Release_Ref ();
            m_pCBackgroundObject = NULL;            
        }

        if (pszBackgroundObjectName)
        {            
            // Create a new instance of the render object to use as the background
            m_pCBackgroundObject = WW3DAssetManager::Get_Instance()->Create_Render_Obj (pszBackgroundObjectName);
            
            ASSERT (m_pCBackgroundObject);
            if (m_pCBackgroundObject)
            {
                // Place the object at world center
                m_pCBackgroundObject->Set_Position (Vector3 (0.00F, 0.00F, 0.00F));
                
                // Calculate the depth the camera should be at by the objects bouding sphere
                float cameraDepth = m_pCBackgroundObject->Get_Bounding_Sphere ().Radius * 4.0F;
                
                CGraphicView *pCGraphicView = GetGraphicView ();
                if (pCGraphicView)
                {
                    // Set the camera's rotation
                    m_pCBackObjectCamera->Set_Transform (pCGraphicView->GetCamera ()->Get_Transform ());
                }

                // Set the camera's position and depth                
                m_pCBackObjectCamera->Set_Position (Vector3 (0.00F, 0.00F, 0.00F));
                //m_pCBackObjectCamera->Set_Depth (cameraDepth);
                m_pCBackObjectCamera->Set_Clip_Planes (1, cameraDepth);
                
                // Add the background object to the scene
					 m_pCBackObjectScene->Add_Render_Object (m_pCBackgroundObject);
            }
        }

        // Remember this for later...
        m_stringBackgroundObject = pszBackgroundObjectName;
    }

    return ;
}


///////////////////////////////////////////////////////////////
//
//  Remove_Object_From_Scene
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Remove_Object_From_Scene (RenderObjClass *prender_obj)
{
	// If the render object is NULL, then remove the current render object
	if (prender_obj == NULL) {
		prender_obj = m_pCRenderObj;
	}

	// Recursively remove objects from the scene (to make sure we get all particle buffers)
	//for (int index = 0; index < prender_obj->Get_Num_Sub_Objects (); index ++) {
	while (prender_obj->Get_Num_Sub_Objects () > 0) {
		RenderObjClass *psub_obj = prender_obj->Get_Sub_Object (0);
		if (psub_obj != NULL) {
			Remove_Object_From_Scene (psub_obj);
		}
		MEMBER_RELEASE (psub_obj);
	}

	// If this is an emitter, then remove its buffer
	if ((prender_obj != NULL) &&
		 prender_obj->Class_ID () == RenderObjClass::CLASSID_PARTICLEEMITTER) {
		
		// Attempt to remove this emitter's buffer
		((ParticleEmitterClass *)prender_obj)->Stop ();
		((ParticleEmitterClass *)prender_obj)->Remove_Buffer_From_Scene ();
		((ParticleEmitterClass *)prender_obj)->Buffer_Scene_Not_Needed ();
	}

	// Remove the render object from the scene (if we have a valid scene)
	if (m_pCScene != NULL) {
		prender_obj->Remove ();
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  Save_Selected_Primitive
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Save_Selected_Primitive (void)
{
	// Assume failure
	bool retval = false;

	// Is this an emitter?
	if ((m_pCRenderObj != NULL) &&
		 (m_pCRenderObj->Class_ID () == RenderObjClass::CLASSID_SPHERE ||
		  m_pCRenderObj->Class_ID () == RenderObjClass::CLASSID_RING)) {
		
		// Build the default filename from the name of the emitter
		CString default_filename = GetDataTreeView ()->GetCurrentSelectionName ();
		default_filename += ".w3d";

		RestrictedFileDialogClass dialog (FALSE,
								  ".w3d",
								  (LPCTSTR)default_filename,
								  OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_EXPLORER,
								  "Westwood 3D Files (*.w3d)|*.~xyzabc||",
								  AfxGetMainWnd ());

		if (m_pCRenderObj->Class_ID () == RenderObjClass::CLASSID_SPHERE) {
			dialog.m_ofn.lpstrTitle = "Export Sphere";
		} else {
			dialog.m_ofn.lpstrTitle = "Export Ring";
		}

		// Ask the user what filename they wish to save as.		
		if (dialog.DoModal () == IDOK) {
			
			// Save the emitter to the requested file
			if (m_pCRenderObj->Class_ID () == RenderObjClass::CLASSID_SPHERE) {
				retval = Save_Current_Sphere (dialog.GetPathName ());
			} else {
				retval = Save_Current_Ring (dialog.GetPathName ());
			}
		}
	}

	// Return the true/false result code
	return retval;
}


///////////////////////////////////////////////////////////////
//
//  Save_Current_Sphere
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Save_Current_Sphere (const CString &filename)
{
	// Assume failure
	bool retval = false;

	//
	// Get the prototype for this object
	//
	SpherePrototypeClass *proto = NULL;
	proto = (SpherePrototypeClass *)WW3DAssetManager::Get_Instance ()->Find_Prototype (m_pCRenderObj->Get_Name ());
	ASSERT (proto != NULL);
	if (proto != NULL) {

		//
		// Get a file object for the new file
		//
		FileClass *file = _TheFileFactory->Get_File (filename);
		if (file) {

			// Open the file for writing
			file->Open (FileClass::WRITE);

			// Save the definition to the file
			ChunkSaveClass csave (file);
			proto->Save (csave);
			retval = true;

			// Close the file
			file->Close ();
			_TheFileFactory->Return_File (file);
		}
	}

	return retval;
}


///////////////////////////////////////////////////////////////
//
//  Save_Current_Ring
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Save_Current_Ring (const CString &filename)
{
	// Assume failure
	bool retval = false;

	//
	// Get the prototype for this object
	//
	RingPrototypeClass *proto = NULL;
	proto = (RingPrototypeClass *)WW3DAssetManager::Get_Instance ()->Find_Prototype (m_pCRenderObj->Get_Name ());
	ASSERT (proto != NULL);
	if (proto != NULL) {

		//
		// Get a file object for the new file
		//
		FileClass *file = _TheFileFactory->Get_File (filename);
		if (file) {

			// Open the file for writing
			file->Open (FileClass::WRITE);

			// Save the definition to the file
			ChunkSaveClass csave (file);
			proto->Save (csave);
			retval = true;

			// Close the file
			file->Close ();
			_TheFileFactory->Return_File (file);
		}
	}

	return retval;
}


///////////////////////////////////////////////////////////////
//
//  Save_Selected_Emitter
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Save_Selected_Emitter (void)
{
	// Assume failure
	bool retval = false;

	// Is this an emitter?
	if ((m_pCRenderObj != NULL) &&
		 m_pCRenderObj->Class_ID () == RenderObjClass::CLASSID_PARTICLEEMITTER) {
		
		// Build the default filename from the name of the emitter
		CString default_filename = GetDataTreeView ()->GetCurrentSelectionName ();
		default_filename += ".w3d";

		RestrictedFileDialogClass dialog (FALSE,
								  ".w3d",
								  (LPCTSTR)default_filename,
								  OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_EXPLORER,
								  "Westwood 3D Files (*.w3d)|*.~xyzabc||",
								  AfxGetMainWnd ());

		// Ask the user what filename they wish to save as.
		dialog.m_ofn.lpstrTitle = "Export Emitter";
		if (dialog.DoModal () == IDOK) {
			
			// Save the emitter to the requested file
			retval = Save_Current_Emitter (dialog.GetPathName ());
		}
	}

	// Return the true/false result code
	return retval;
}


///////////////////////////////////////////////////////////////
//
//  Save_Current_Emitter
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Save_Current_Emitter (const CString &filename)
{
	// Assume failure
	bool retval = false;
	// Get the prototype for this aggregate
	ParticleEmitterPrototypeClass *proto = NULL;
	proto = (ParticleEmitterPrototypeClass *)WW3DAssetManager::Get_Instance ()->Find_Prototype (m_pCRenderObj->Get_Name ());
	ASSERT (proto != NULL);
	if (proto != NULL) {

		// Get the definition from the prototype
		ParticleEmitterDefClass *pdefinition = proto->Get_Definition ();
		ASSERT (pdefinition != NULL);
		if (pdefinition != NULL) {

			// Get a file object for the new file
			FileClass *pfile = _TheFileFactory->Get_File (filename);
			if (pfile) {

				// Open the file for writing
				pfile->Open (FileClass::WRITE);

				// Save the definition to the file
				ChunkSaveClass save_chunk (pfile);
				retval = (pdefinition->Save_W3D (save_chunk) == WW3D_ERROR_OK);

				// Close the file
				pfile->Close ();
				_TheFileFactory->Return_File (pfile);
			}
		}
	}
	// Return the true/false result code
	return retval;
}


///////////////////////////////////////////////////////////////
//
//  Save_Selected_Sound_Object
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Save_Selected_Sound_Object (void)
{
	bool retval = false;

	//
	// Is this a sound render object?
	//
	if ((m_pCRenderObj != NULL) &&
		 m_pCRenderObj->Class_ID () == RenderObjClass::CLASSID_SOUND)
	{		
		//
		// Build the default filename from the name of the emitter
		//
		CString default_filename = GetDataTreeView ()->GetCurrentSelectionName ();
		default_filename += ".w3d";

		RestrictedFileDialogClass dialog (FALSE,
								  ".w3d",
								  (LPCTSTR)default_filename,
								  OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_EXPLORER,
								  "Westwood 3D Files (*.w3d)|*.~xyzabc||",
								  AfxGetMainWnd ());

		//
		// Ask the user what filename they wish to save as.
		//
		dialog.m_ofn.lpstrTitle = "Export Sound Object";
		if (dialog.DoModal () == IDOK) {
			
			//
			// Save the sound object to the requested file
			//
			retval = Save_Current_Sound_Object (dialog.GetPathName ());
		}
	}

	return retval;
}


///////////////////////////////////////////////////////////////
//
//  Save_Current_Sound_Object
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Save_Current_Sound_Object (const CString &filename)
{
	bool retval = false;

	//
	// Get the prototype for this sound object
	//
	SoundRenderObjPrototypeClass *proto = NULL;
	proto = (SoundRenderObjPrototypeClass *)WW3DAssetManager::Get_Instance ()->Find_Prototype (m_pCRenderObj->Get_Name ());
	
	ASSERT (proto != NULL);
	if (proto != NULL) {

		//
		// Get the definition from the prototype
		//
		SoundRenderObjDefClass *definition = proto->Peek_Definition ();
		ASSERT (definition != NULL);
		if (definition != NULL) {

			//
			// Get a file object for the new file
			//
			FileClass *file = _TheFileFactory->Get_File (filename);
			if (file) {

				//
				// Open the file for writing
				//
				file->Open (FileClass::WRITE);

				//
				// Save the definition to the file
				//
				ChunkSaveClass csave (file);
				retval = (definition->Save_W3D (csave) == WW3D_ERROR_OK);

				//
				// Close the file
				//
				file->Close ();
				_TheFileFactory->Return_File (file);
			}
		}
	}

	return retval;
}


///////////////////////////////////////////////////////////////
//
//  Auto_Assign_Bones
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Auto_Assign_Bones (void)
{
	if (m_pCRenderObj != NULL) {
		bool bupdate_prototype = false;

		// Loop through all the bones in this render object
		int bone_count = m_pCRenderObj->Get_Num_Bones ();
		for (int index = 0; index < bone_count; index ++) {
			const char *pbone_name = m_pCRenderObj->Get_Bone_Name (index);
			
			// Attempt to find a render object with the same name as this bone
			if (WW3DAssetManager::Get_Instance ()->Render_Obj_Exists (pbone_name)) {
				
				// Add this render object to the bone
				RenderObjClass *prender_obj = WW3DAssetManager::Get_Instance ()->Create_Render_Obj (pbone_name);
				m_pCRenderObj->Add_Sub_Object_To_Bone (prender_obj, index);
				MEMBER_RELEASE (prender_obj);
				bupdate_prototype = true;
			}
		}

		if (bupdate_prototype) {
			Update_Aggregate_Prototype (*m_pCRenderObj);
		}
	}
		
	return ;
}


///////////////////////////////////////////////////////////////
//
//  Save_Selected_Aggregate
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Save_Selected_Aggregate (void)
{
	// Assume failure
	bool retval = false;

	// Do we have a valid render object?
	if (m_pCRenderObj != NULL) {

		// Build the default filename from the name of render object
		CString default_filename = GetDataTreeView ()->GetCurrentSelectionName ();
		default_filename += ".w3d";

		RestrictedFileDialogClass dialog (FALSE,
								  ".w3d",
								  (LPCTSTR)default_filename,
								  OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_EXPLORER,
								  "Westwood 3D Files (*.w3d)|*.~xyzabc||",
								  AfxGetMainWnd ());

		// Ask the user what filename they wish to save as.
		dialog.m_ofn.lpstrTitle = "Export Aggregate";
		if (dialog.DoModal () == IDOK) {
			
			// Save the aggregate to the requested file
			retval = Save_Current_Aggregate (dialog.GetPathName ());
		}
	}

	// Return the true/false result code
	return retval;
}


///////////////////////////////////////////////////////////////
//
//  Save_Current_Aggregate
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Save_Current_Aggregate (const CString &filename)
{
	// Assume failure
	bool retval = false;
	// Get the prototype for this aggregate
	AggregatePrototypeClass *proto = NULL;
	proto = (AggregatePrototypeClass *)WW3DAssetManager::Get_Instance ()->Find_Prototype (m_pCRenderObj->Get_Name ());
	ASSERT (proto != NULL);
	if (proto != NULL) {

		// Get the definition from the prototype
		AggregateDefClass *pdefinition = proto->Get_Definition ();
		ASSERT (pdefinition != NULL);
		if (pdefinition != NULL) {

			// Get a file object for the new file
			FileClass *pfile = _TheFileFactory->Get_File (filename);
			if (pfile) {

				// Open the file for writing
				pfile->Open (FileClass::WRITE);

				// Save the definition to the file
				ChunkSaveClass save_chunk (pfile);
				retval = (pdefinition->Save_W3D (save_chunk) == WW3D_ERROR_OK);

				// Close the file
				pfile->Close ();
				_TheFileFactory->Return_File (pfile);
			}
		}
	}
	// Return the true/false result code
	return retval;
}


///////////////////////////////////////////////////////////////
//
//  Update_Aggregate_Prototype
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Update_Aggregate_Prototype (RenderObjClass &render_obj)
{
	// Build a definition object from the render object
	AggregateDefClass *pdefinition = new AggregateDefClass (render_obj);
	AggregatePrototypeClass *pprototype = new AggregatePrototypeClass (pdefinition);

	// Add this prototype to the asset manager
	WW3DAssetManager::Get_Instance ()->Remove_Prototype (pdefinition->Get_Name ());
	WW3DAssetManager::Get_Instance ()->Add_Prototype (pprototype);
	return ;
}


///////////////////////////////////////////////////////////////
//
//  Update_LOD_Prototype
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Update_LOD_Prototype (HLodClass &hlod)
{
	// Build a definition object from the render object
	HLodDefClass *pdefinition = new HLodDefClass (hlod);
	HLodPrototypeClass *pprototype = new HLodPrototypeClass (pdefinition);

	// Add this prototype to the asset manager
	WW3DAssetManager::Get_Instance ()->Remove_Prototype (pdefinition->Get_Name ());
	WW3DAssetManager::Get_Instance ()->Add_Prototype (pprototype);
	return ;
}


///////////////////////////////////////////////////////////////
//
//  Animate_Camera
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Animate_Camera (bool banimate)
{
	m_bAnimateCamera = banimate;
	
	// Restore the camera if we are done animating it
	if (m_bAnimateCamera == false) {
		::AfxGetMainWnd ()->SendMessage (WM_COMMAND, MAKEWPARAM (IDM_CAMERA_RESET, 0));
	}
	
	return ;
}


///////////////////////////////////////////////////////////////
//
//  Make_Movie
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Make_Movie (void)
{
	// Hide the mouse cursor when we're making a movie.
	bool restore_cursor = Is_Cursor_Shown();
	Show_Cursor(false);
	int i;

	CGraphicView *graphic_view= GetGraphicView ();
	if (m_pCRenderObj && m_pCAnimation) {

		// Get the directory where this executable was run from
		TCHAR filename[MAX_PATH];
		::GetModuleFileName (NULL, filename, sizeof (filename));

		// Strip the filename from the path
		LPTSTR ppath = ::strrchr (filename, '\\');
		if (ppath != NULL) {
			ppath[0] = 0;
		}
		::SetCurrentDirectory (filename);

		// Rewind the animation
		if (m_pCAnimCombo)
		{
			for (i = 0; i < m_pCAnimCombo->Get_Num_Anims(); i++)
				m_pCAnimCombo->Set_Frame(i, 0.0f);

			m_pCRenderObj->Set_Animation (m_pCAnimCombo);
		}
		else
			m_pCRenderObj->Set_Animation (m_pCAnimation, (int)0);
		graphic_view->RepaintView (FALSE);

		// Begin our movie
		WW3D::Pause_Movie (true);
		WW3D::Start_Movie_Capture ("Grab", 30);
		WW3D::Pause_Movie (true);
		
		float frames = m_pCAnimation->Get_Num_Frames ();
		float frame_inc = m_pCAnimation->Get_Frame_Rate () / 30.0F;
		DWORD ticks = 1000 / 30;

		// Loop through all the frames of animation
		for (float frame = 0; frame <= (frames - 1.0F); frame += frame_inc) {

			if (m_pCAnimCombo)
			{
				for (i = 0; i < m_pCAnimCombo->Get_Num_Anims(); i++)
					m_pCAnimCombo->Set_Frame(i, frame);
				m_pCRenderObj->Set_Animation (m_pCAnimCombo);
			}
			else
				m_pCRenderObj->Set_Animation (m_pCAnimation, frame);

			// Should we be updating the camera?
			if (m_bAnimateCamera) {
				int index = m_pCRenderObj->Get_Bone_Index ("CAMERA");
				if (index != -1) {
					
					// Convert the bone's transform into a camera transform
					Matrix3D	transform = m_pCRenderObj->Get_Bone_Transform (index);												
					Matrix3D cam_transform (Vector3 (0, -1, 0), Vector3 (0, 0, 1), Vector3 (-1, 0, 0), Vector3 (0, 0, 0));
					Matrix3D new_transform = transform * cam_transform;

					// Pass the new transform onto the camera
					CameraClass *pcamera = GetGraphicView()->GetCamera ();
					pcamera->Set_Transform (new_transform);
				}
			}	
			
			graphic_view->RepaintView (FALSE, ticks);
			graphic_view->RepaintView (FALSE, 1);
			WW3D::Update_Movie_Capture ();

			if (::GetAsyncKeyState (VK_ESCAPE) < 0) {
				break;
			}
		}

		// Stop capturing the movie data
		WW3D::Stop_Movie_Capture ();
	}

	// Restore the mouse cursor to its previous visibility state.
	Show_Cursor(restore_cursor);

	return ;
}


///////////////////////////////////////////////////////////////
//
//  Build_Emitter_List
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Build_Emitter_List
(
	EmitterInstanceListClass *emitter_list,
	LPCTSTR emitter_name,
	RenderObjClass *render_obj
)
{
	//
	// If the render object is NULL, then start from the current render object
	//
	if (render_obj == NULL) {
		render_obj = m_pCRenderObj;
	}

	//
	// Recursively walk through the objects in the scene
	//
	for (int index = 0; index < render_obj->Get_Num_Sub_Objects (); index ++) {
		RenderObjClass *psub_obj = render_obj->Get_Sub_Object (index);
		if (psub_obj != NULL) {
			Build_Emitter_List (emitter_list, emitter_name, psub_obj);
		}
		MEMBER_RELEASE (psub_obj);
	}
	
	//
	// Is this the emitter we are requesting?
	//
	if ((render_obj != NULL) &&
		 (render_obj->Class_ID () == RenderObjClass::CLASSID_PARTICLEEMITTER) &&
		 (::lstrcmpi (emitter_name, render_obj->Get_Name ()) == 0)) {
		
		emitter_list->Add_Emitter ((ParticleEmitterClass *)render_obj);
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  Show_Cursor
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Show_Cursor (bool onoff)
{
	if (m_pCursor == NULL) {
		Create_Cursor ();
	}

	m_pCursor->Set_Hidden (!onoff);
	return ;
}


///////////////////////////////////////////////////////////////
//
//  Is_Cursor_Shown
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Is_Cursor_Shown (void) const
{
	return m_pCursor != NULL && m_pCursor->Is_Not_Hidden_At_All ();
}


///////////////////////////////////////////////////////////////
//
//  Set_Cursor
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Set_Cursor (LPCTSTR resource_name)
{	
	m_pCursor->Set_Texture (::Load_RC_Texture (resource_name));
	return ;
}


///////////////////////////////////////////////////////////////
//
//  Create_Cursor
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Create_Cursor (void)
{
	if (m_pCursor == NULL) {
		m_pCursor = new ScreenCursorClass;
		m_pCursor->Set_Window (GetGraphicView ()->m_hWnd);
		m_pCursor->Set_Texture (::Load_RC_Texture ("cursor.tga"));
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  Count_Particles
//
///////////////////////////////////////////////////////////////
int
CW3DViewDoc::Count_Particles (RenderObjClass *render_obj)
{
	int count = 0;

	//
	// If the render object is NULL, then start from the current render object
	//
	if (render_obj == NULL) {
		render_obj = m_pCRenderObj;
	}

	//
	// Recursively walk through the subobjects
	//
	if (render_obj != NULL) {
		for (int index = 0; index < render_obj->Get_Num_Sub_Objects (); index ++) {
			RenderObjClass *psub_obj = render_obj->Get_Sub_Object (index);
			if (psub_obj != NULL) {
				count += Count_Particles (psub_obj);
			}
			MEMBER_RELEASE (psub_obj);
		}


		// If this is an emitter, then remove its buffer
		if (render_obj->Class_ID () == RenderObjClass::CLASSID_PARTICLEEMITTER) {
			
			//
			//	Add the number of particles in the buffer to the total
			//
			ParticleEmitterClass *emitter = static_cast<ParticleEmitterClass *> (render_obj);
			ParticleBufferClass *buffer = emitter->Peek_Buffer ();
			if (buffer != NULL) {
				count += buffer->Get_Particle_Count ();
			}		
		}
	}

	return count;
}


///////////////////////////////////////////////////////////////
//
//  Update_Particle_Count
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Update_Particle_Count (void)
{
	int particles = Count_Particles ();
	((CMainFrame *)::AfxGetMainWnd ())->Update_Particle_Count (particles);
	return ;
}


///////////////////////////////////////////////////////////////
//
//  Switch_LOD
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Switch_LOD (int increment, RenderObjClass *render_obj)
{
	//
	// If the render object is NULL, then start from the current render object
	//
	if (render_obj == NULL) {
		render_obj = m_pCRenderObj;
	}

	//
	// Recursively walk through the subobjects
	//
	if (render_obj != NULL) {
		for (int index = 0; index < render_obj->Get_Num_Sub_Objects (); index ++) {
			RenderObjClass *psub_obj = render_obj->Get_Sub_Object (index);
			if (psub_obj != NULL) {
				Switch_LOD (increment, psub_obj);
			}
			MEMBER_RELEASE (psub_obj);
		}

		//
		// If this is an HLOD then switch its LOD
		//
		if (render_obj->Class_ID () == RenderObjClass::CLASSID_HLOD) {
			int current_lod = ((HLodClass *)render_obj)->Get_LOD_Level ();
			((HLodClass *)render_obj)->Set_LOD_Level (current_lod + increment);
		}
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  Toggle_Alternate_Materials
//
///////////////////////////////////////////////////////////////
void 
CW3DViewDoc::Toggle_Alternate_Materials(RenderObjClass * render_obj)
{
	// 
	// If the render object is NULL, start from the current render object
	//
	if (render_obj == NULL) {
		render_obj = m_pCRenderObj;
	}

	if (render_obj != NULL) {

		// 
		// If this is a mesh, toggle the materials
		//
		if (render_obj->Class_ID() == RenderObjClass::CLASSID_MESH) {
			MeshModelClass * mdl = ((MeshClass *)render_obj)->Get_Model();
			mdl->Enable_Alternate_Material_Description(!mdl->Is_Alternate_Material_Description_Enabled());
		}

		// 
		// Recurse into any children
		//
		for (int index = 0; index < render_obj->Get_Num_Sub_Objects(); index++) {
			RenderObjClass * sub_obj = render_obj->Get_Sub_Object(index);
			Toggle_Alternate_Materials(sub_obj);
		}
	}
		
	return;
}


///////////////////////////////////////////////////////////////
//
//  Lookup_Path
//
///////////////////////////////////////////////////////////////
bool
CW3DViewDoc::Lookup_Path (LPCTSTR asset_name, CString &path) 
{
	bool retval = false;

	//
	//	Loop over every file we've loaded...
	//
	int counter = m_LoadList.Count ();
	while ((counter --) && !retval) {
		
		//
		//	Does this path contain the W3D this asset came from?
		//
		CString curr_path		= m_LoadList[counter];
		CString curr_asset	= ::Asset_Name_From_Filename (curr_path);
		if (::lstrcmpi (asset_name, curr_asset) == 0) {
			path = curr_path;
			retval = true;
		}
	}

	return retval;
}


///////////////////////////////////////////////////////////////
//
//  Copy_Assets_To_Dir
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Copy_Assets_To_Dir (LPCTSTR directory) 
{	
	CDataTreeView *data_tree = GetDataTreeView ();
	SANITY_CHECK ((m_pCRenderObj != NULL && data_tree != NULL)) {
		return ;
	}

	//
	//	Attempt to locate the file this asset came from
	//
	LPCTSTR asset_name = data_tree->GetCurrentSelectionName ();
	CString filename;
	if (Lookup_Path (asset_name, filename)) {
		
		CString src_path	= ::Strip_Filename_From_Path (filename);
		CString dest_path	= directory;
		::Delimit_Path (src_path);
		::Delimit_Path (dest_path);

		//
		// Get a list of dependent files from the render object
		//
		DynamicVectorClass<StringClass> dependency_list;
		m_pCRenderObj->Build_Dependency_List (dependency_list);		

		//
		//	Loop over the list of dependent files and copy them
		// each to the destination directory
		//
		DynamicVectorClass<CString> copy_failure_list;
		int counter = dependency_list.Count ();
		while (counter --) {

			//
			//	Determine the source and destination filenames
			//
			StringClass filename		= dependency_list[counter];
			CString src_filename		= src_path + CString (filename);
			CString dest_filename	= dest_path + CString (filename);

			//
			//	Copy the file
			//
			if (::Copy_File (src_filename, dest_filename, true) == false) {
				copy_failure_list.Add (src_filename);
			}
		}

		//
		//	Let the user know if something failed to copy
		//
		if (copy_failure_list.Count () > 0) {
			CString message = "Unable to copy the following files:\r\n\r\n";

			counter = copy_failure_list.Count ();
			while (counter --) {
				message += copy_failure_list[counter];
				message += "\r\n";
			}

			::MessageBox (::AfxGetMainWnd ()->m_hWnd, message, "Copy Failure", MB_ICONERROR | MB_OK);
		}

	} else {

		//
		//	Let the user know if we were unable to find the asset's W3D file
		//
		CString message;
		message.Format ("Unable to find file for asset: %s.", asset_name);
		::MessageBox (::AfxGetMainWnd ()->m_hWnd, message, "File Not Found", MB_ICONEXCLAMATION | MB_OK);
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  Set_Texture_Path1
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Set_Texture_Path1 (LPCTSTR path)
{		
	if (m_TexturePath1.CompareNoCase (path) != 0) {

		//
		//	Pass the new search path onto the File Factory
		//
		if (::lstrlen (path) > 0) {
			_TheSimpleFileFactory->Append_Sub_Directory(path);
		}

		m_TexturePath1 = path;
		theApp.WriteProfileString ("Config", "TexturePath1", m_TexturePath1);
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  Set_Texture_Path2
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Set_Texture_Path2 (LPCTSTR path)
{	
	if (m_TexturePath2.CompareNoCase (path) != 0) {
		
		//
		//	Pass the new search path onto Surrender
		//
		if (::lstrlen (path) > 0) {
			_TheSimpleFileFactory->Append_Sub_Directory(path);
		}
		m_TexturePath2 = path;
		theApp.WriteProfileString ("Config", "TexturePath2", m_TexturePath2);
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  Import_Facial_Animation
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Import_Facial_Animation (const CString &heirarchy_name, const CString &filename)
{
	//
	// Crate a new text file object that can be used to import the animation
	//
	TextFileClass *anim_desc_file = new TextFileClass (filename);
	if (anim_desc_file->Open () == (int)true) {

		//
		// Create the new animation and import its data from the text file
		//
		HMorphAnimClass *new_anim = new HMorphAnimClass;
		new_anim->Import (heirarchy_name, *anim_desc_file);
		
		//
		//	Give the new animation a name
		//
		CString new_name;
		CString animation_name = ::Asset_Name_From_Filename (filename);
		animation_name.MakeUpper ();
		new_name.Format ("%s.%s", (LPCTSTR)heirarchy_name, (LPCTSTR)animation_name);
		new_anim->Set_Name (new_name);

		//
		// Add this animation to the asset manager
		//
		WW3DAssetManager::Get_Instance ()->Add_Anim (new_anim);

		//
		// Save this animation to disk
		//
		CString directory = ::Strip_Filename_From_Path (filename);
		::Delimit_Path (directory);
		CString path = directory + animation_name + CString (".w3d");
		RawFileClass *animation_file = new RawFileClass (path);
		if (	animation_file->Create () == (int)true &&
				animation_file->Open (FileClass::WRITE) == (int)true)
		{
			ChunkSaveClass csave (animation_file);
			new_anim->Save_W3D (csave);
			animation_file->Close ();
		}
		SAFE_DELETE (animation_file);

		//
		// Cleanup
		//
		anim_desc_file->Close ();
		MEMBER_RELEASE (new_anim);
		SAFE_DELETE (anim_desc_file);
	}

	return ;
}


///////////////////////////////////////////////////////////////
//
//  Get_Current_HTree
//
///////////////////////////////////////////////////////////////
const HTreeClass *
CW3DViewDoc::Get_Current_HTree (void) const
{
	const HTreeClass *htree = NULL;

	if (m_pCRenderObj != NULL) {
		htree = m_pCRenderObj->Get_HTree ();
	}

	return htree;
}


///////////////////////////////////////////////////////////////
//
//  Save_Camera_Settings
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Save_Camera_Settings (void)
{
	theApp.WriteProfileInt ("Config", "UseManualFOV", m_ManualFOV);
	theApp.WriteProfileInt ("Config", "UseManualClipPlanes", m_ManualClipPlanes);	

	CGraphicView *graphic_view	= ::Get_Graphic_View ();
	CameraClass *camera			= graphic_view->GetCamera ();
	if (camera != NULL) {
		
		double hfov = camera->Get_Horizontal_FOV ();
		double vfov = camera->Get_Vertical_FOV ();

		float znear = 0;
		float zfar = 0;
		camera->Get_Clip_Planes (znear, zfar);

		CString hfov_string;
		CString vfov_string;
		CString znear_string;
		CString zfar_string;
		hfov_string.Format ("%f", hfov);
		vfov_string.Format ("%f", vfov);
		znear_string.Format ("%f", znear);
		zfar_string.Format ("%f", zfar);

		theApp.WriteProfileString ("Config", "hfov", hfov_string);
		theApp.WriteProfileString ("Config", "vfov", vfov_string);
		theApp.WriteProfileString ("Config", "znear", znear_string);
		theApp.WriteProfileString ("Config", "zfar", zfar_string);		
	}
	
	return ;
}


///////////////////////////////////////////////////////////////
//
//  Load_Camera_Settings
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Load_Camera_Settings (void)
{
	m_ManualFOV				= (theApp.GetProfileInt ("Config", "UseManualFOV", 0) == TRUE);
	m_ManualClipPlanes	= (theApp.GetProfileInt ("Config", "UseManualClipPlanes", 0) == TRUE);

	CGraphicView *graphic_view	= GetGraphicView ();
	if (graphic_view != NULL) {
		CameraClass *camera = graphic_view->GetCamera ();
		if (camera != NULL) {

			//
			// Should we load the FOV settings from the registry?
			//
			if (m_ManualFOV) {

				CString hfov_string = theApp.GetProfileString ("Config", "hfov", "0");
				CString vfov_string = theApp.GetProfileString ("Config", "vfov", "0");

				double hfov = ::atof (hfov_string);
				double vfov = ::atof (vfov_string);
				
				camera->Set_View_Plane (hfov, vfov);
			}

			//
			//	Should we load the clip planes from the registry?
			//
			if (m_ManualClipPlanes) {

				CString znear_string	= theApp.GetProfileString ("Config", "znear", "0.1F");
				CString zfar_string	= theApp.GetProfileString ("Config", "zfar", "100.0F");

				float znear	= ::atof (znear_string);
				float zfar		= ::atof (zfar_string);

				camera->Set_Clip_Planes (znear, zfar);
				
				if (m_pCScene != NULL) {
					m_pCScene->Set_Fog_Range (znear, zfar);
					m_pCScene->Recalculate_Fog_Planes();
				}
			}
		}
	}

	return ;
}

///////////////////////////////////////////////////////////////
//
//  Render_Dazzles
//
///////////////////////////////////////////////////////////////
void
CW3DViewDoc::Render_Dazzles (CameraClass * camera)
{
	if (m_pDazzleLayer != NULL) {
		m_pDazzleLayer->Render(camera);
	}
}


void
CW3DViewDoc::SetBackgroundColor (const Vector3 &backgroundColor)
{
	m_backgroundColor = backgroundColor;

	// If this assert fires, then we will be getting the background color
	// and the fog color out of sync. That would look funky.
	ASSERT(m_pCScene);
	if (m_pCScene)
		m_pCScene->Set_Fog_Color(backgroundColor);
}


void
CW3DViewDoc::EnableFog (bool enable)
{
	if (m_pCScene)
	{
		m_pCScene->Set_Fog_Enable(enable);
		m_bFogEnabled = enable;
	}
}