cvcamera.cpp

Windows上的MUD客户端程序

/*----------------------------------------------------------------------------
                        _                              _ _       
        /\             | |                            | (_)      
       /  \   _ __   __| |_ __ ___  _ __ ___   ___  __| |_  __ _ 
      / /\ \ | '_ \ / _` | '__/ _ \| '_ ` _ \ / _ \/ _` | |/ _` |
     / ____ \| | | | (_| | | | (_) | | | | | |  __/ (_| | | (_| |
    /_/    \_\_| |_|\__,_|_|  \___/|_| |_| |_|\___|\__,_|_|\__,_|

    The contents of this file are subject to the Andromedia Public
	License Version 1.0 (the "License"); you may not use this file
	except in compliance with the License. You may obtain a copy of
	the License at http://www.andromedia.com/APL/

    Software distributed under the License is distributed on an
	"AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	implied. See the License for the specific language governing
	rights and limitations under the License.

    The Original Code is Pueblo client code, released November 4, 1998.

    The Initial Developer of the Original Code is Andromedia Incorporated.
	Portions created by Andromedia are Copyright (C) 1998 Andromedia
	Incorporated.  All Rights Reserved.

	Andromedia Incorporated                         415.365.6700
	818 Mission Street - 2nd Floor                  415.365.6701 fax
	San Francisco, CA 94103

    Contributor(s):
	--------------------------------------------------------------------------
	   Chaco team:  Dan Greening, Glenn Crocker, Jim Doubek,
	                Coyote Lussier, Pritham Shetty.

					Wrote and designed original codebase.

------------------------------------------------------------------------------

	Implementation for the ChQvPCameraRenderData class for  Intel 3DR and 
	Microsoft's RealityLab.

----------------------------------------------------------------------------*/

// $Header: /home/cvs/chaco/modules/client/msw/ChGraphx/CvCamera.cpp,v 2.27 1996/10/03 21:46:12 jimd Exp $

#include "grheader.h"

#include <QvInfo.h>
#include <QvState.h>
#include "ChMaze.h"
#include "CvConvrt.h"
#include "CvTrnsfm.h"
#include "CvNormal.h"
#include "CvInstnc.h"
#include "CvType.h"
#include "CvBound.h"
#include "ChRenderData.h"
#include "GxQuaternion.h"

#include "ChVrmlTransition.h"


ChQvPCameraRenderData::ChQvPCameraRenderData(QvPerspectiveCamera *pCamera, ChQvBuildState* state ) : 
	ChQvRenderBaseData(),
	m_boolPerspective(true), 
	m_pCamera(pCamera),
	m_boolNew(true),
	m_boolSynchEnabled(true)
{
#if defined(CH_VRML_EVENTS)
	if(!m_pDispatcher)
	{
		m_pDispatcher = new	ChVrmlDispatcher;
		Init();
	}
#endif
	Attach(pCamera);
	m_strName = MakeName(state);
	ChRenderContext *pRC = ((ChQvState*)state)->GetView()->GetRenderContext();
	m_pRC = pRC;
	#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
	m_transform = m_pRC->GetModelTransform();
	#endif

	#if 1
	if(!m_strName.IsEmpty()) pRC->AddCamera(pCamera, m_strName);
	#endif
}

ChQvPCameraRenderData::ChQvPCameraRenderData(QvOrthographicCamera *pCamera, ChQvBuildState* state ) : 
	ChQvRenderBaseData(),
	m_boolPerspective(false), 
	m_pCamera((QvPerspectiveCamera *)((QvNode*)pCamera)),
	m_boolNew(true),
	m_boolSynchEnabled(true)
{
#if defined(CH_VRML_EVENTS)
	if(!m_pDispatcher)
	{
		m_pDispatcher = new	ChVrmlDispatcher;
		Init();
	}
#endif
	Attach(pCamera);
	m_strName = MakeName(state);
	ChRenderContext *pRC = ((ChQvState*)state)->GetView()->GetRenderContext();
	m_pRC = pRC;
	#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
	m_transform = m_pRC->GetModelTransform();
	#endif
	pRC->AddCamera(pCamera, m_strName);
}

ChQvPCameraRenderData::~ChQvPCameraRenderData()
{
#if 1
	//if(!m_strName.IsEmpty()) m_pRC->RemoveCamera(m_strName);
#endif
}

void ChQvPCameraRenderData::Init()
{
	ChQvRenderBaseData::Init();
#if defined(CH_VRML_EVENTS)

	AddVrmlDispatcher("set_orientation", SFRotation, OnSetOrientation);
	AddVrmlDispatcher("set_position", SFVec3f, OnSetPosition);

#endif

};


void ChQvPCameraRenderData::Term()
{
#if defined(CH_VRML_EVENTS)
	delete m_pDispatcher;
	m_pDispatcher = 0;
#endif
}

void ChQvPCameraRenderData::SetDirty(bool boolDirty)
{
	ChQvRenderBaseData::SetDirty(boolDirty);
#if 1
	if(boolDirty && IsSynchEnabled())
	{
		Synch();
		if(m_pRC && m_pNode == m_pRC->GetCurrentCamera())
		{
			SetRenderer();

				// And set the context dirty
			m_pRC->SetDirty();
		}
	}
	//ChQvRenderBaseData::SetDirty(false);
#endif
} 


ChQvPCameraRenderData *ChQvPCameraRenderData::SetLoc(GxVec3f &loc)
{
	m_loc = loc;
	// Notify window that we moved
	if(m_pRC->GetCurrentCamera() == GetNode())
	{
		((ChMazeWnd*)(m_pRC->GetWnd()))->OnCameraChange(ChMazeWnd::cameraMoved);
	}
	return this;
};
ChQvPCameraRenderData *ChQvPCameraRenderData::SetDir(GxVec3f &dir)
{
	m_dir = dir; 
	// Notify window that we turned
	if(m_pRC->GetCurrentCamera() == GetNode())
	{
		((ChMazeWnd*)(m_pRC->GetWnd()))->OnCameraChange(ChMazeWnd::cameraTurned);
	}
	return this;
};

ChQvPCameraRenderData *ChQvPCameraRenderData::SetUp(GxVec3f &up)
{
	m_up = up; 
	// Notify window that we turned
	if(m_pRC->GetCurrentCamera() == GetNode())
	{
		((ChMazeWnd*)(m_pRC->GetWnd()))->OnCameraChange(ChMazeWnd::cameraTurned);
	}
	return this;
};

GxTransform3Wf ChQvPCameraRenderData::GetTransform()
{
	return GxTransform3Wf(m_cameraTransform);
}
GxTransform3Wf ChQvPCameraRenderData::GetInverseTransform()
{
	#if defined(CH_USE_3DR)
	return GxTransform3Wf(m_invCameraTransform);
	#else
	return m_cameraTransform.Inverse();
	#endif
}

GxTransform3Wf ChQvPCameraRenderData::GetClipTransform()
{
	return GxTransform3Wf(m_camClipTransform);
}




string ChQvPCameraRenderData::MakeName(ChQvBuildState* state)
{
	string name;
	QvNode * pParentNode = 0;
	ChQvGroupInstance *pParentInst = state->GetCurrentParent();
	if(pParentInst)
	{
		pParentNode = pParentInst->GetNode();
	}
	#if 1
	if(pParentNode)
	{
		string strType;
		if(pParentNode->GetType(strType) == typeQvSwitch && pParentNode->getName() == "Cameras")
		{
			name = (char *)(m_pNode->getName().getString());
			if(name.IsEmpty())
			{
				ChRenderContext *pRC = ((ChQvState*)state)->GetView()->GetRenderContext();
				name.Format("Camera %d", pRC->GetCameraCount());
			}
		}
	}
	#else
	string prefix;

	if(pParentNode)
	{
		string strType;
		if(pParentNode->GetType(strType) == typeQvSwitch)
		{
			if(pParentNode->getName() == "Cameras") prefix = "Cameras:";
		}
	}
	name = prefix + (char *)(m_pNode->getName().getString());
	if(name.IsEmpty())
	{
		ChRenderContext *pRC = ((ChQvState*)state)->GetView()->GetRenderContext();
		name.Format("Camera %d", pRC->GetCameraCount());
	}
	#endif

	return name;
}

ChQvPCameraRenderData * ChQvPCameraRenderData::Reset()
{
	SetLoc(m_startLoc);
	SetDir(m_startDir);
	SetUp (m_startUp);
	return this;
}

void ChQvPCameraRenderData::SynchCamera()		  // Set camera node fields to agree with this
{
	if(m_boolPerspective)
	{
		EnableSynch(false);	// turn off to prevent redundant computation
		QvPerspectiveCamera *pCamera = (QvPerspectiveCamera*)((QvNode*)m_pCamera);

		pCamera->position.setValue(&m_loc);

		GxVec3f 	dirZ (0.0f, 0.0f, -1.0f);
		GxVec3f	axis;
		float angle;

		#if (!defined(CH_VRML_VIEWER) && !defined(CH_VRML_PLUGIN )) || defined(CH_VRML_EVENTS)

		GxQuaternion quat(m_dir, m_up);
		quat.AxisAngle(axis, angle);

		axis.normalize();
		#else
		// We don't really need this except for Pueblo or VRML 2.0, so do it lazy
		// The quaternion code takes longer. This way doesn't pay attention to up
		// but if we don't use it who cares? Do the same thing for ortho camera
		// later too.
		axis = dirZ.cross(m_dir);
		if (axis.dot(axis) < 1e-12)
		{
			axis.set( 0, 1, 0);
		}
		axis.normalize();
		float cosa = dirZ.dot(m_dir);	// both were unit vectors before
		angle = acos(cosa);
		#endif

		float orient[4];
		orient[0] = axis.x();
		orient[1] = axis.y();
		orient[2] = axis.z();
		orient[3] = angle;
		pCamera->orientation.setValue(orient);

		EnableSynch();

}
	else
	{
		QvOrthographicCamera *pCamera = (QvOrthographicCamera*)((QvNode*)m_pCamera);
		pCamera->position.value[0] = m_loc.x();
		pCamera->position.value[1] = m_loc.y();
		pCamera->position.value[2] = m_loc.z();
		GxVec3f 	dirZ(0.0f, 0.0f, -1.0f);
		GxVec3f	axis;
		float angle;

		#if (!defined(CH_VRML_VIEWER) && !defined(CH_VRML_PLUGIN )) || defined(CH_VRML_EVENTS)

		GxQuaternion quat(m_dir, m_up);
		quat.AxisAngle(axis, angle);

		axis.normalize();
		#else
		axis = dirZ.cross(m_dir);
		if (axis.dot(axis) < 1e-12)
		{
			axis.set( 0, 1, 0);
		}
		axis.normalize();
		float cosa = dirZ.dot(m_dir);	// both were unit vectors before
		angle = acos(cosa);
		#endif

		pCamera->orientation.axis[0] = axis.x();
		pCamera->orientation.axis[1] = axis.y();
		pCamera->orientation.axis[2] = axis.z();

		pCamera->orientation.angle = angle;
	}
#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
	SetRenderer();
#endif
}	

void ChQvPCameraRenderData::Synch()		  // Set this' fields to agree with camera node
{
	GxVec3f	up, yAxis(0.0f, 1.0f, 0.0f);		// starting loc for look dirs
	GxVec3f	dir, dira(0.0f, 0.0f, -1.0f);		// will rotate later
	GxVec3f 	loc, axis;
	float angle;

	// Get the node's data; be safe about it
	if(m_boolPerspective)
	{
		QvPerspectiveCamera *pCamera = (QvPerspectiveCamera*)((QvNode*)m_pCamera);
		Qv2Gx(pCamera->position, loc);
		Qv2Gx(pCamera->orientation.axis, axis);
		angle = pCamera->orientation.angle;
	}
	else
	{
		QvOrthographicCamera *pCamera = (QvOrthographicCamera*)((QvNode*)m_pCamera);
		Qv2Gx(pCamera->position, loc);
		Qv2Gx(pCamera->orientation.axis, axis);
		angle = pCamera->orientation.angle;
	}

	angle = -angle;


	// Inventor puts the camera in transformed world (model) coordinates,
	// RLAB's camera is in the base frame. Apply our stack transform to the 
	// frame, then apply the camera loc and direction. 
	// Remember VRML is RHS, but RLab is LHS

	GxTransform3Wf	stackMat = m_transform;
	GxTransform3Wf	rotMat(axis, -angle);

										  
	GxTransform3Wf cameraMat = rotMat;		  // up/down has nothing to do with the transform jwd 12/7/95

	dir = cameraMat * dira;
	dir.normalize();

	if(m_pRC->GetViewerMode() != walk )
	{
		up  = cameraMat * yAxis;
	}
	else						// We're walking; keep camera level
	{							// This computation is not pure VRML,
								// but it keeps camera manipulations much cleaner for
								// walking situations. The camera acts more camera-like 
								// and less airplane-like.

		GxVec3f n = yAxis.cross(dir);				// normal to plane defined by (dir, yaxis)

		if (n.dot(n) > SMIDGEON)
		{
			up = dir.cross(n);
		}
		else
		{
			// special case; looking straight up or down
			up  = cameraMat * yAxis;
		} 

		if (up.dot(up) < SMIDGEON)
		{
			up = yAxis;