guus
/
reman3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
reman3/Rayman_X/cpa/tempgrp/OCA/src/caminter.cpp

1410 lines
56 KiB
C++
Raw Blame History

//#################################################################################
//
// BASE CLASS OF YOUR DLL interface
//
//#################################################################################
#include <direct.h>
#include "stdafx.h"
#include "acp_base.h"
#include "geo.h"
#include "gli.h"
#include "ITF.h"
#include "caminter.hpp"
#include "ogd.h"
#include "X:\Cpa\Main\inc\_EditID.h"
//CPA 2 Corneliu Babiuc 04-05-98
//include files for level path & name
#include "incGAM.h"
#include "DPT.h"
//END CPA2 Corneliu Babiuc 04-05-98
// infos
static CString g_csOCAName = "Camera";
static CString g_csOCAAuthor = "Fabien Bole-Feysot & Chantal Oury";
static CString g_csOCAVersion = "V 3.0.1 18/03/98";
static CString g_csOCAFrenchHelpFile = "Camera.hlp";
static CString g_csOCAEnglishHelpFile = "";
// the DLL global definition
tdstDLLIdentity g_stCameraIdentity;
#define C_PI 3.14159265
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
Camera_Interface::Camera_Interface(void)
{
// CPA_Ed_1 MP BEGIN
//mouse handler
m_bRotateOn=FALSE;
m_bIsMoving=FALSE;
hcursorR=AfxGetApp()->LoadCursor(MAKEINTRESOURCE(CPA_IDC_ROTATECAMERA));
hcursorM=AfxGetApp()->LoadCursor(MAKEINTRESOURCE(CPA_IDC_MOVECAMERA));
// CPA_Ed_1 MP END
m_p_stDLLIdentity = &g_stCameraIdentity;
// Does your DLL can output in main game view ?
m_stBaseDLLDefinition.bCanOutputIn3DView = FALSE;
m_fTranslationStep = 1;
m_fRotationStep = (float) (C_PI/32);
// TODO : Add your own code here
SetCurrent(FALSE);
SetEditorInfo(g_csOCAName, g_csOCAAuthor, g_csOCAVersion, g_csOCAFrenchHelpFile, g_csOCAEnglishHelpFile);
m_p_oKeyConfiguration = NULL;
m_p_oInertCameraGeomObject = NULL;
m_hLastEngineCamera = NULL;
m_bFirstTime = TRUE;
m_lSlotForEngineCamera = -1;
m_lSlotForLastEditorCamera = -1;
m_bCameraTargetMode = FALSE;
// ANNECY MT NewInterface 26/03/98 {
m_eReferentialDisplayMode = DisplayDownLeft;
// ENDANNECY MT NewInterface }
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::fn_vJustAfterRegistered()
{
CString types[] = {C_szCameraObjectTypeName};
fn_vRegisterObjectsType(types,1);
Camera::StaticInit();
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::fn_vConstruct()
{
// Keyboard
InitKeyboard();
// Display
SetReferentialDisplayMode( m_eReferentialDisplayMode ); // update ToolBar
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::fn_vInitListByType (CPA_World *pWorld)
{
pWorld->fn_vAddANewListByType ("Camera", this);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::fn_vBeforeEditor(void)
{
DEV_ViewPort3D *p_oMainvp;
GLI_tdxHandleToCamera hEngineCamera, hCopyOfEngineCamera;
ACP_tdxHandleOfObject hObject;
CPA_CameraSlots *p_oSlotCamera;
CPA_EditorBase *pGeomDLL;
Camera *p_oEngineCamera;
CPA_SuperObject *p_oCameraSO;
CPA_BaseObject *p_oOwnerFile;
CString csCameraName = "Inert_Camera_Picture";
p_oSlotCamera = GetMainWorld()->GetWorld()->GetCameraSlots();
p_oMainvp = (DEV_ViewPort3D*)(M_GetMainDeviceNum(0)->GetViewPort());
// get the game engine camera
hEngineCamera = p_oMainvp->GetEngineCamera();
ASSERT(hEngineCamera != NULL); // there's no game camera!!!
// save the real game engine camera in the specific variable
m_hLastEngineCamera = hEngineCamera;
if (m_p_oInertCameraGeomObject == NULL)
{
// load the camera geometric representation
hObject = GLI_pLoadGeometricInFile("edt_data\\objects\\camera\\camera.mod^Geometric:camera");
//create the corresponding editor geometric object
pGeomDLL = GetMainWorld () -> GetObjectDLLWithName (C_szDLLGeometryName);
p_oOwnerFile = (CPA_BaseObject*) pGeomDLL -> OnQueryAction( this, C_uiGetOwnerByFileName, (LPARAM)"edt_data\\objects\\camera\\camera.mod");
m_p_oInertCameraGeomObject = new Geometry3D(pGeomDLL, p_oOwnerFile, (ACP_tdxHandleOfObject)hObject, csCameraName);
}
if (m_bFirstTime)
{
// this part is executed only once, the first time
//CPA2 Corneliu Babiuc 30-04-98
// m_bFirstTime = FALSE;
//END CPA2 Corneliu Babiuc 30-04-98
// init the main world camera slots
m_lSlotForEngineCamera = p_oSlotCamera->ReserveASlot("Copy Of Engine Camera");
m_lSlotForLastEditorCamera = p_oSlotCamera->ReserveASlot("Last Editor Camera");
//Stefan Dumitrean 24-06-98 ( slots )
p_oSlotCamera->ActivatePrevCamTip();
p_oSlotCamera->SetCurrentSlot(p_oSlotCamera->SetSpecialSlotNr(p_oSlotCamera->ReserveASlot("Default Slot")));
//End Stefan Dumitrean 24-06-98 ( slots )
}
// make a copy of the engine camera
GLI_xCreateCamera(&hCopyOfEngineCamera, GLI_C_lPersCamWithoutDistorsion);
GLI_vCopyCamera(hCopyOfEngineCamera,hEngineCamera);
// make a new Camera from the copy of the engine structure
p_oEngineCamera = new Camera(InertCamera,this,GetMainWorld(),hCopyOfEngineCamera);
// and put this new camera in the slot 0
p_oSlotCamera->SaveCameraInSlot(m_lSlotForEngineCamera,"Copy Of Engine Camera",p_oEngineCamera,MakeACopy);
//Stefan Dumitrean 26-06-98 ( slots )
p_oSlotCamera->SaveCameraInSlot(p_oSlotCamera->GetSpecialSlotNr(),"Default Slot",p_oEngineCamera,MakeACopy);
//End Stefan Dumitrean 26-06-98 (slots)
// associate a camera superobject and a geometric superobject and a geometric object to the camera
//Stefan Dumitrean 24-06-98 ( slots )
//if the current slot is the "mode change slot" initialize with engine camera
if( !m_bFirstTime && p_oSlotCamera->GetCurrentSlot() >= 0 )
p_oCameraSO = AssociateSuperObject( (Camera*)p_oSlotCamera->GetCameraFromSlot( p_oSlotCamera->GetCurrentSlot(), MakeACopy ) );
else
p_oCameraSO = AssociateSuperObject(p_oEngineCamera);
//End Stefan Dumitrean 24-06-98 ( slots )
// put this camera in the main viewport
p_oMainvp->ChangeCamera(p_oCameraSO);
// and put this camera in the hierarchy
InsertCameraInHierarchy(p_oCameraSO);
// move the camera ahead a bit to avoid auto-selection of stdcam
CPA_CameraCoords oCoords(CameraCoordinates,0,0,(float)0.3);
p_oEngineCamera->Translate(&oCoords);
//CPA2 Corneliu Babiuc 30-04-98
//read the saved slots
if (m_bFirstTime)
{
m_bFirstTime = FALSE;
LoadSlotsPositions(p_oEngineCamera);
}
//END CPA2 Corneliu Babiuc 30-04-98
// get the active camera
p_oEngineCamera = (Camera*) GetMainWorld()->GetFRMBase()->m_oGeneralDialogBar.m_p_oCamera;
// and show its dialogbar
if (p_oEngineCamera != NULL)
p_oEngineCamera->ShowDialogBar();
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::fn_vBeforeEngine(void)
{
DEV_ViewPort3D *p_oMainvp;
CPA_SuperObject *p_oCameraSO;
Camera *p_oCamera;
CPA_CameraSlots *p_oCameraslots;
// get the main world slots
p_oCameraslots = GetMainWorld()->GetWorld()->GetCameraSlots();
// get the game viewport
p_oMainvp = (DEV_ViewPort3D*)(M_GetMainDeviceNum(0)->GetViewPort());
// put a NULL camera in the game viewport, and get the game viewport last camera
// don't remember the previous camera
p_oCameraSO = p_oMainvp->ChangeCamera(NULL,FALSE);
p_oCamera = (Camera*)p_oCameraSO->GetObject();
// save this camera in the reserved slot
p_oCameraslots->SaveCameraInSlot(m_lSlotForLastEditorCamera,"Last Editor Camera",p_oCamera,MakeACopy);
//Stefan Dumitrean 24-06-98 ( slots )
//saves the current slot
//when we go back to the editor this slot will be restored
if( p_oCameraslots->GetCurrentSlot() >= 0 )
p_oCameraslots->SaveCameraInSlot(p_oCameraslots->GetCurrentSlot(),"",p_oCamera,MakeACopy);
SaveSlotsPositions();
//End Stefan Dumitrean 24-06-98 ( slots )
// put back the engine camera in the game viewport
GLI_xSetViewportCamera(p_oMainvp->m_hDisplayDevice,p_oMainvp->m_hDisplayViewport,m_hLastEngineCamera);
GLI_xAdjustCameraToViewport (p_oMainvp->m_hDisplayDevice,p_oMainvp->m_hDisplayViewport,m_hLastEngineCamera);
// get the active camera
p_oCamera = (Camera*) GetMainWorld()->GetFRMBase()->m_oGeneralDialogBar.m_p_oCamera;
// and hide its dialogbar
if (p_oCamera != NULL)
p_oCamera->HideDialogBar();
// destroy the old game viewport editor camera
DestroyCamera(p_oCameraSO);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::fn_vAddObjectsToDraw(GLD_tdstViewportAttributes *p1 , GLI_tdstLight *p2, DEV_ViewPort* p3)
{
MTH3D_tdstVector stOrigin,stP1,stP2,stP3;
POS_tdstCompletePosition stMatrix,stMatrix2;
DEV_ViewPort3D *p_oViewPort;
Camera *p_oCamera;
GEO_tdstColor ColBidon;
long lLineColor;
POS_fn_vSetIdentityMatrix(&stMatrix);
POS_fn_vSetIdentityMatrix(&stMatrix2);
// ANNECY MT NewInterface 26/03/98 {
if (m_eReferentialDisplayMode ==DisplayNone)
return;
// ENDANNECY MT NewInterface }
// get the current camera
p_oViewPort = (DEV_ViewPort3D*)p3;
p_oCamera = (Camera*)p_oViewPort->GetCamera();
if (p_oCamera == NULL)
return;
ColBidon.xR=0.5;
ColBidon.xG=0.5;
ColBidon.xB=0.5;
ColBidon.xA=0.5;
GLI_xGetCameraMatrix(((GLI_tdstSpecificAttributesFor3D*)(p1->p_vSpecificToXD))->p_stCam,&stMatrix);
// init for drawing
GLI_xLoadMatrix(&stMatrix);
GLI_vSetFog(100,100,200,&ColBidon);
#define C_Grid_Offset 0.008
#define C_Grid_NbLines 9
// prepare the Origin Point
// get the camera matrix
p_oCamera->GetMatrix(&stMatrix2);
// get the camera position
POS_fn_vGetTranslationVector(&stMatrix2,&stOrigin);
// buil the offset vector, in camera coordinates, from camera to origin
// ANNECY MT NewInterface 26/03/98 {
if( m_eReferentialDisplayMode == DisplayDownLeft )
{
MTH3D_M_vSetVectorElements(&stP1,0.22 - C_Grid_Offset*(C_Grid_NbLines-1)/2,
-0.17 + C_Grid_Offset*(C_Grid_NbLines-1)/2,
0.35);
}
else if( m_eReferentialDisplayMode == DisplayDownRight )
{
MTH3D_M_vSetVectorElements(&stP1,-0.21 + C_Grid_Offset*(C_Grid_NbLines-1)/2,
-0.17 + C_Grid_Offset*(C_Grid_NbLines-1)/2,
0.35);
}
// ENDANNECY MT NewInterface }
// translate it in world coordinates
p_oCamera->CameraToWorldCoordinates_Vector(stP1);
// add it to camera position --> origin
MTH3D_M_vAddVector(&stOrigin,&stP1,&stOrigin);
// put the origin at the beginning of the grid
MTH3D_M_vSetVectorElements(&stP1,- C_Grid_Offset * (C_Grid_NbLines-1)/2,
- C_Grid_Offset * (C_Grid_NbLines-1)/2,
(float)0.00);
MTH3D_M_vAddVector(&stOrigin,&stOrigin,&stP1);
// draw the grid X lines
// p3 = origin
// p2 = offset
// p1 = extremite
MTH3D_M_vSetVectorElements(&stP2,(float)0.0,(float)C_Grid_Offset,(float)0.00);
MTH3D_M_vCopyVector(&stP3,&stOrigin);
MTH3D_M_vCopyVector(&stP1,&stOrigin);
MTH3D_M_vSetXofVector(&stP1,MTH3D_M_xGetXofVector(&stP3) + C_Grid_Offset * (C_Grid_NbLines-1));
lLineColor = 0xf0f0f0;
for (int i=0;i<C_Grid_NbLines;i++)
{
GLI_xDraw3DLine16 (p1,&stP3,&stP1,lLineColor);
MTH3D_M_vAddVector(&stP1,&stP1,&stP2);
MTH3D_M_vAddVector(&stP3,&stP3,&stP2);
lLineColor ^= 0xf0f0f0;
}
// draw the grid Y lines
// p3 = origin
// p2 = extremite
// p1 = offset
MTH3D_M_vSetVectorElements(&stP1,(float)C_Grid_Offset,(float)0.0,(float)0.00);
MTH3D_M_vCopyVector(&stP3,&stOrigin);
MTH3D_M_vCopyVector(&stP2,&stOrigin);
MTH3D_M_vSetYofVector(&stP2,MTH3D_M_xGetYofVector(&stP3) + C_Grid_Offset * (C_Grid_NbLines-1));
lLineColor = 0xf0f0f0;
for (i=0;i<C_Grid_NbLines;i++)
{
GLI_xDraw3DLine16 (p1,&stP3,&stP2,lLineColor);
MTH3D_M_vAddVector(&stP2,&stP2,&stP1);
MTH3D_M_vAddVector(&stP3,&stP3,&stP1);
lLineColor ^= 0xf0f0f0;
}
// put the origin in the center of the grid
MTH3D_M_vSetVectorElements(&stP1,C_Grid_Offset * (C_Grid_NbLines-1)/2,
C_Grid_Offset * (C_Grid_NbLines-1)/2,
(float)0.00);
MTH3D_M_vAddVector(&stOrigin,&stOrigin,&stP1);
// CPA2 ASilvescu 98-04-13
#define CYLINDER 0.0015f
if(GetInterface()->fn_bConsX())
for(int i=0; i<20; i++)
{
MTH3D_M_vSetVectorElements(&stP1, 0.0f, (float)CYLINDER*sin(i*6.28/20), (float)CYLINDER*cos(i*6.28/20));
MTH3D_M_vAddVector(&stP2, &stP1, &stOrigin);
stP1.xX = 0.02f;
MTH3D_M_vAddVector(&stP1, &stP1, &stOrigin);
GLI_xDraw3DLine16 (p1, &stP1, &stP2, 0x00FF00);
}
if(GetInterface()->fn_bConsY())
for(int i=0; i<20; i++)
{
MTH3D_M_vSetVectorElements(&stP1, (float)CYLINDER*sin(i*6.28/20), 0.0f, (float)CYLINDER*cos(i*6.28/20));
MTH3D_M_vAddVector(&stP2, &stP1, &stOrigin);
stP1.xY = 0.02f;
MTH3D_M_vAddVector(&stP1, &stP1, &stOrigin);
GLI_xDraw3DLine16 (p1, &stP1, &stP2, 0xFF00FF);
}
if(GetInterface()->fn_bConsZ())
for(int i=0; i<20; i++)
{
MTH3D_M_vSetVectorElements(&stP1, (float)CYLINDER*sin(i*6.28/20), (float)CYLINDER*cos(i*6.28/20), 0.0f);
MTH3D_M_vAddVector(&stP2, &stP1, &stOrigin);
stP1.xZ = 0.03f;
MTH3D_M_vAddVector(&stP1, &stP1, &stOrigin);
GLI_xDraw3DLine16 (p1, &stP1, &stP2, 0x00FFFF);
}
// End CPA2 ASilvescu 98-04-13
// draw the X axis
MTH3D_M_vSetVectorElements(&stP1,(float)0.02,(float)0,(float)0);
MTH3D_M_vAddVector(&stP1,&stP1,&stOrigin);
GLI_xDraw3DLine16 (p1,&stOrigin,&stP1,0x00FF00);
// draw the X letter
MTH3D_M_vSetVectorElements(&stP1,(float)0.022,(float)0,(float)-0.002);
MTH3D_M_vSetVectorElements(&stP2,(float)0.026,(float)0,(float)0.002);
MTH3D_M_vAddVector(&stP1,&stP1,&stOrigin);
MTH3D_M_vAddVector(&stP2,&stP2,&stOrigin);
GLI_xDraw3DLine16 (p1,&stP1,&stP2,0x00FF00);
MTH3D_M_vSetVectorElements(&stP1,(float)0.022,(float)0,(float)0.002);
MTH3D_M_vSetVectorElements(&stP2,(float)0.026,(float)0,(float)-0.002);
MTH3D_M_vAddVector(&stP1,&stP1,&stOrigin);
MTH3D_M_vAddVector(&stP2,&stP2,&stOrigin);
GLI_xDraw3DLine16 (p1,&stP1,&stP2,0x00FF00);
// draw the Y axis
MTH3D_M_vSetVectorElements(&stP2,(float)0,(float)0.02,(float)0);
MTH3D_M_vAddVector(&stP2,&stP2,&stOrigin);
GLI_xDraw3DLine16 (p1,&stOrigin,&stP2,0xFF00FF);
// draw the Y letter
MTH3D_M_vSetVectorElements(&stP1,(float)0,(float)0.022,(float)0.002);
MTH3D_M_vSetVectorElements(&stP2,(float)0,(float)0.024,(float)0);
MTH3D_M_vAddVector(&stP1,&stP1,&stOrigin);
MTH3D_M_vAddVector(&stP2,&stP2,&stOrigin);
GLI_xDraw3DLine16 (p1,&stP1,&stP2,0xFF00FF);
MTH3D_M_vSetVectorElements(&stP1,(float)0,(float)0.026,(float)0.002);
MTH3D_M_vSetVectorElements(&stP2,(float)0,(float)0.022,(float)-0.002);
MTH3D_M_vAddVector(&stP1,&stP1,&stOrigin);
MTH3D_M_vAddVector(&stP2,&stP2,&stOrigin);
GLI_xDraw3DLine16 (p1,&stP1,&stP2,0xFF00FF);
// draw the Z axis
MTH3D_M_vSetVectorElements(&stP3,(float)0,(float)0,(float)0.03);
MTH3D_M_vAddVector(&stP3,&stP3,&stOrigin);
GLI_xDraw3DLine16 (p1,&stOrigin,&stP3,0x00FFFF);
// draw the Z letter
MTH3D_M_vSetVectorElements(&stP1,(float)-0.002,(float)0,(float)0.036);
MTH3D_M_vSetVectorElements(&stP2,(float)0.002,(float)0,(float)0.036);
MTH3D_M_vAddVector(&stP1,&stP1,&stOrigin);
MTH3D_M_vAddVector(&stP2,&stP2,&stOrigin);
GLI_xDraw3DLine16 (p1,&stP1,&stP2,0x00FFFF);
MTH3D_M_vSetVectorElements(&stP1,(float)-0.002,(float)0,(float)0.032);
MTH3D_M_vAddVector(&stP1,&stP1,&stOrigin);
GLI_xDraw3DLine16 (p1,&stP1,&stP2,0x00FFFF);
MTH3D_M_vSetVectorElements(&stP2,(float)0.002,(float)0,(float)0.032);
MTH3D_M_vAddVector(&stP2,&stP2,&stOrigin);
GLI_xDraw3DLine16 (p1,&stP1,&stP2,0x00FFFF);
GLI_xPopMatrix();
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
ACP_tdxHandleOfObject Camera_Interface::fn_hGetBoundingVolume(CPA_BaseObject *_p_oCamera)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
if (p_oCamera->GetCameraType() == InertCamera)
{
ASSERT(m_p_oInertCameraGeomObject != NULL);
return ((CPA_ObjectDLLBase*)m_p_oInertCameraGeomObject->GetEditor())->fn_hGetBoundingVolume(m_p_oInertCameraGeomObject);
}
else
{
return NULL;
}
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::fn_vComputeBoundingVolume(CPA_BaseObject *_p_oCamera)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
if (p_oCamera->GetCameraType() == InertCamera)
{
ASSERT(m_p_oInertCameraGeomObject != NULL);
((CPA_ObjectDLLBase*)m_p_oInertCameraGeomObject->GetEditor())->fn_vComputeBoundingVolume(m_p_oInertCameraGeomObject);
return;
}
else
{
return;
}
}
//==================================================================================================
//==================================================================================================
//==================================================================================================
//==================================================================================================
//==================================================================================================
//==================================================================================================
//==================================================================================================
// communication with viewport
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::DestroyCamera(CPA_SuperObject *_p_oCameraSO)
{
Camera *p_oCamera = (Camera *) _p_oCameraSO->GetObject();
ASSERT(p_oCamera != NULL);
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
// disactivate camera
p_oCamera->Disactivate();
// if the old camera was in the hierarchy,
if (_p_oCameraSO->fn_bIsUnderObject(M_GetWorld()->GetRoot()))
{
// remove camera SO from hierarchy and delete SO
GetInterface()->fn_bDeleteObjectInHierarchy(_p_oCameraSO,FALSE,FALSE,TRUE);
// and delete camera
delete p_oCamera;
}
else
{
// delete SuperObject and camera
delete _p_oCameraSO;
delete p_oCamera;
}
}
//=========================================================================================
//=========================================================================================
//=========================================================================================
//=========================================================================================
//=========================================================================================
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::Activate(CPA_BaseObject *_p_oCamera, DEV_ViewPort3D *p_oViewPort, CPA_DialogBar *p_oPopUpParent, CPoint oPos)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->Activate(p_oViewPort,p_oPopUpParent,oPos);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::Disactivate(CPA_BaseObject *_p_oCamera)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->Disactivate();
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::SetRotationAxisSystem(CPA_BaseObject *_p_oCamera, tdeAxisSystem eSystem)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->SetRotationAxisSystem(eSystem);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::SetTranslationAxisSystem(CPA_BaseObject *_p_oCamera, tdeAxisSystem eSystem)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->SetTranslationAxisSystem(eSystem);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
tdeAxisSystem Camera_Interface::GetRotationAxisSystem(CPA_BaseObject *_p_oCamera)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
return p_oCamera->GetRotationAxisSystem();
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::GetMatrix(CPA_BaseObject *_p_oCamera, POS_tdstCompletePosition *p_oMatrix)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->GetMatrix(p_oMatrix);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::SetMatrix(CPA_BaseObject *_p_oCamera, POS_tdstCompletePosition *p_oMatrix)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->SetMatrix(p_oMatrix);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
tdeAxisSystem Camera_Interface::GetTranslationAxisSystem(CPA_BaseObject *_p_oCamera)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
return p_oCamera->GetTranslationAxisSystem();
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
BOOL Camera_Interface::SetRotationCenterType(CPA_BaseObject *_p_oCamera, tdeRotationCenterType eRotCenterType)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
return p_oCamera->SetRotationCenterType(eRotCenterType);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
tdeRotationCenterType Camera_Interface::GetRotationCenterType(CPA_BaseObject *_p_oCamera)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
return p_oCamera->GetRotationCenterType();
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
tdeRotationCenterType Camera_Interface::GetEffectiveRotationCenterType(CPA_BaseObject *_p_oCamera)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
return p_oCamera->GetEffectiveRotationCenterType();
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
BOOL Camera_Interface::SetTargetType(CPA_BaseObject *_p_oCamera, tdeTargetType eTargetType)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
return p_oCamera->SetTargetType(eTargetType);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
tdeTargetType Camera_Interface::GetTargetType(CPA_BaseObject *_p_oCamera)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
return p_oCamera->GetTargetType();
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
BOOL Camera_Interface::ZoomOnTarget(CPA_BaseObject *_p_oCamera, CPA_SuperObject *pTarget)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->ZoomOnTarget(pTarget);
return TRUE;
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::SetRotationCenterPoint(CPA_BaseObject *_p_oCamera, CPA_CameraCoords *p_oRotationCenter, tdeCoordsType eType)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->SetRotationCenterPoint(p_oRotationCenter,eType);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
BOOL Camera_Interface::SetRotationCenterSuperObject(CPA_BaseObject *_p_oCamera, CPA_SuperObject *p_oSuperObject)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
return p_oCamera->SetRotationCenterSuperObject(p_oSuperObject);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
BOOL Camera_Interface::GetRotationCenter(CPA_BaseObject *_p_oCamera, MTH3D_tdstVector &r_stCenter)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
return p_oCamera->GetRotationCenter(r_stCenter);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::SetTargetPoint(CPA_BaseObject *_p_oCamera, CPA_CameraCoords *p_oRotationCenter)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->SetTargetPoint(p_oRotationCenter);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
BOOL Camera_Interface::SetTargetSuperObject(CPA_BaseObject *_p_oCamera, CPA_SuperObject *p_oSuperObject)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
return p_oCamera->SetTargetSuperObject(p_oSuperObject);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
BOOL Camera_Interface::GetTarget(CPA_BaseObject *_p_oCamera, MTH3D_tdstVector &r_stTarget)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
return p_oCamera->GetTarget(r_stTarget);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::Translate(CPA_BaseObject *_p_oCamera, CPA_CameraCoords *p_oOffset, BOOL bUserDefinedAxis)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->Translate(p_oOffset,bUserDefinedAxis);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::SetPosition(CPA_BaseObject *_p_oCamera, CPA_CameraCoords *p_oPos)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->SetPosition(p_oPos);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::Rotate(CPA_BaseObject *_p_oCamera, tdeAxis eAxis, double dAngle)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->Rotate(eAxis,dAngle);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::SetRotation(CPA_BaseObject *_p_oCamera, double dAngleX, double dAngleY, double dAngleZ)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->SetRotation(dAngleX,dAngleY,dAngleZ);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::Update(CPA_BaseObject *_p_oCamera)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->Update();
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::CameraToWorldCoordinates_Point(CPA_BaseObject *_p_oCamera, MTH3D_tdstVector &r_stVector)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->CameraToWorldCoordinates_Point(r_stVector);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::CameraToWorldCoordinates_Vector(CPA_BaseObject *_p_oCamera, MTH3D_tdstVector &r_stVector)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->CameraToWorldCoordinates_Vector(r_stVector);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::WorldToCameraCoordinates_Point(CPA_BaseObject *_p_oCamera, MTH3D_tdstVector &r_stVector)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->WorldToCameraCoordinates_Point(r_stVector);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::WorldToCameraCoordinates_Vector(CPA_BaseObject *_p_oCamera, MTH3D_tdstVector &r_stVector)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
p_oCamera->WorldToCameraCoordinates_Vector(r_stVector);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
CPA_SuperObject *Camera_Interface::CreateDefaultCamera()
{
// make a new inert camera
return CreateInertCamera(NULL,"default_camera");
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::InsertCameraInHierarchy(CPA_SuperObject *p_oCameraSO)
{
Camera *p_oCamera;
ASSERT(p_oCameraSO != NULL);
p_oCamera = (Camera*)p_oCameraSO->GetObject();
ASSERT(p_oCamera != NULL);
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
GetInterface()->fn_bInsertObjectInHierarchy(p_oCameraSO,GetInterface()->GetSpecificInterface()->GetDynamicRoot(),
FALSE,FALSE,FALSE);
// must pass FALSE else crash when a new device is created because the redraw
// occurs before the new camera is ready !
//ANNECY Shaitan Correction 20/02/98
// GetInterface()->fn_vCancelCurrentSelection(FALSE);
//ENDANNECY Shaitan Correction
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
CPA_BaseObject *Camera_Interface::CopySlotCamera(CPA_BaseObject* _p_oCamera)
{
Camera *p_oCamera;
ASSERT(_p_oCamera != NULL);
p_oCamera = (Camera*)_p_oCamera;
ASSERT(p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
return new Camera(*p_oCamera);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::PutCameraInViewPort(CPA_BaseObject *_p_oCamera,DEV_ViewPort3D *p_oViewPort, BOOL bWithPrevCam)
{
Camera *p_oNewCamera,*p_oOldCamera;
CPA_SuperObject *p_oSO,*p_oSOGeom;
GEO_tdxHandleToMatrix hCameraMatrix,hSOMatrix;
long lSlotNum = -1;
ASSERT(_p_oCamera != NULL);
p_oNewCamera = (Camera*)_p_oCamera;
ASSERT(_p_oCamera->fn_bIsOfType(C_szCameraObjectTypeName));
// get actual viewport camera
p_oSO = p_oViewPort->GetCameraSO();
p_oOldCamera = (Camera *)p_oSO->GetObject();
ASSERT(p_oOldCamera != NULL);
// Get the name of the old camera
CString csOldCameraName = p_oOldCamera->GetName ();
// Delete the old camera so that the new camera can have the same name
// delete p_oOldCamera;
// rename new camera with name of old camera
if (p_oNewCamera->fn_eRename(csOldCameraName))
p_oNewCamera->SetDefaultUniqueName();
// attach the new camera to the old camera superobject
p_oSO->SetObject(p_oNewCamera);
// sets the SO at the same place that the camera
// ( ==> copy the camera matrix in the SO matrix)
hCameraMatrix = p_oNewCamera->GetCameraMatrix();
hSOMatrix = HIE_fn_hGetSuperObjectMatrix((HIE_tdxHandleToSuperObject) p_oSO->GetData());
GEO_M_vCopyMatrix(hSOMatrix,hCameraMatrix);
// change the camera geometric representation according to the camera type
p_oSOGeom = p_oSO->GetSuperObjectFirstChild();
switch (p_oNewCamera->GetCameraType())
{
case InertCamera:
p_oSOGeom->SetObject(GetInertCameraGeomObject());
break;
case ActorCamera:
break;
}
// change the camera in the viewport
p_oViewPort->ChangeCamera(p_oSO,bWithPrevCam);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
// accept delete if the camera is not active
BOOL Camera_Interface::fn_bAcceptModifDelete(CPA_List<CPA_SuperObject> *p_oListObjects, tdeStatus eStatus)
{
POSITION stPos;
BOOL bResult;
CPA_SuperObject *p_oSO;
Camera *p_oCamera;
bResult = TRUE;
stPos = p_oListObjects->GetHeadPosition();
while (stPos)
{
p_oSO = p_oListObjects->GetNext(stPos);
if (p_oSO->GetObject()->fn_bIsOfType(C_szCameraObjectTypeName))
{
p_oCamera = (Camera*)p_oSO->GetObject();
if (p_oCamera->IsActive())
return FALSE;
}
}
return TRUE;
}
// ANNECY MT NewInterface 26/03/98 {
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
void Camera_Interface::SetReferentialDisplayMode(tdeDisplayReferential eDisplayMode)
{
m_eReferentialDisplayMode = eDisplayMode;
GetInterface() -> GetFrameBase() -> m_oGeneralDialogBar . fn_vUpdateAxisMode( (int) m_eReferentialDisplayMode );
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
tdeDisplayReferential Camera_Interface::GetReferentialDisplayMode()
{
return m_eReferentialDisplayMode;
}
// ENDANNECY MT NewInterface }
//==================================================================================================
//==================================================================================================
//==================================================================================================
//==================================================================================================
//================ P R I V A T E ===================================================================
//==================================================================================================
//==================================================================================================
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
// create an inert camera with its SuperObject and graphic object
CPA_SuperObject *Camera_Interface::CreateInertCamera(GLI_tdxHandleToCamera hEngineCamera,CString csName,CString csFileName,CString csSectionName)
{
Camera *p_oCamera;
// create the camera
if (hEngineCamera == NULL)
p_oCamera = new Camera(InertCamera,this,GetMainWorld(),csName,csFileName,csSectionName);
else
p_oCamera = new Camera(InertCamera,this,GetMainWorld(),hEngineCamera,csName,csFileName,csSectionName);
// create SuperObject associated
return AssociateSuperObject(p_oCamera);
}
//********************************************************************************************************
//********************************************************************************************************
//********************************************************************************************************
// create a superObject, a Geometric superobject and a geometric object for this camera
CPA_SuperObject *Camera_Interface::AssociateSuperObject(Camera *p_oCamera)
{
CPA_SuperObject *p_oCameraSO,*p_oCameraGeom;
GEO_tdxHandleToMatrix hCameraMatrix,hSOGeomMatrix;
MTH3D_tdstVector stRelativePos;
// create the superobject
p_oCameraSO = GetInterface()->GetNewSuperObject(E_ss_NoSave,C_Dynamic);
// link camera and object
p_oCameraSO->SetObject(p_oCamera);
// sets the SO at the same place that the camera
// (replace the SO matrix by the camera matrix so that camera and SO have the same matrix)
hCameraMatrix = p_oCamera->GetCameraMatrix();
HIE_fn_vSetSuperObjectMatrix ((HIE_tdxHandleToSuperObject) p_oCameraSO->GetData() , hCameraMatrix);
// create the camera geometric SuperObject
p_oCameraGeom = GetInterface()->GetNewSuperObject(E_ss_NoSave,C_Protected);
p_oCameraGeom->SetEditProtected(TRUE);
p_oCameraGeom->SetSuperObjectOwner(p_oCameraSO);
//move the camera geometric representation back a little bit to avoid auto-selection
MTH3D_M_vSetVectorElements(&stRelativePos,0,0,(float)-0.05);
hSOGeomMatrix = HIE_fn_hGetSuperObjectMatrix(p_oCameraGeom->GetStruct());
POS_fn_vSetTranslationVector(hSOGeomMatrix,&stRelativePos);
// link the SO with the geometric object
p_oCameraGeom->SetObject(m_p_oInertCameraGeomObject);
// the geom SO is the son of the camera SO
p_oCameraSO->AddTail(p_oCameraGeom);
return p_oCameraSO;
}
//CPA 2 Corneliu Babiuc 30-04-98
//***********************************************************************************************
// Method : void Camera_Interface::LoadSlotsPositions(CPA_BaseObject * p_oCamera)
// Date : 24-03-98
//***********************************************************************************************
// Description :
// Load from .ECA file, camera position and name
// Parameters:
// p_oCamera: - pointer to current camera
// Author : Laurentiu Barza
// Modification: Corneliu Babiuc 05-05-98
//***********************************************************************************************
//BEGIN CPA2 Laurentiu Barza 24-03-98
void Camera_Interface::LoadSlotsPositions(CPA_BaseObject * p_oCamera)
{
FILE * fInitialPositionsFile;
char szName[250];
char readData[80];
char readChar;
//Stefan Dumitrean 2-07-98 ( slots )
char szNameEditor[250], szNameSelection[250];
//End Stefan Dumitrean 2-07-98 ( slots )
//get the camera slots
CPA_CameraSlots * p_oSlotCamera = GetMainWorld()->GetWorld()->GetCameraSlots();
ASSERT(p_oSlotCamera);
POS_tdstCompletePosition stSlotMatrix;
//construct the ECA file name
strcpy(szName, fn_szGetLevelsDataPath());
strcat(szName,"\\");
strcat(szName,fn_p_szGetLevelName());
strcat(szName,"\\");
strcat(szName,fn_p_szGetLevelName());
strcat(szName,".eca");
if((fInitialPositionsFile = fopen(szName, "r")) != NULL)
{
while (!feof(fInitialPositionsFile))
{
POS_fn_vSetIdentityMatrix(&stSlotMatrix);
//read camera's description
if( fscanf(fInitialPositionsFile,"%s %c %[^\"] %c", readData, &readChar, szName, &readChar) <4)
{ //wrong format
break;
}
// STM - camera's never have scale, so transform mat == rotation matrix
fscanf(fInitialPositionsFile,"%s %c %f %f %f %c", readData,&readChar,&stSlotMatrix.stTranslationVector.xX,&stSlotMatrix.stTranslationVector.xY,&stSlotMatrix.stTranslationVector.xZ,&readChar );
fscanf(fInitialPositionsFile,"%s %c %f %f %f %c", readData,&readChar,&stSlotMatrix.stTransformMatrix.stCol_0.xX,&stSlotMatrix.stTransformMatrix.stCol_0.xY,&stSlotMatrix.stTransformMatrix.stCol_0.xZ,&readChar );
fscanf(fInitialPositionsFile,"%s %f %f %f %c", readData,&stSlotMatrix.stTransformMatrix.stCol_1.xX,&stSlotMatrix.stTransformMatrix.stCol_1.xY,&stSlotMatrix.stTransformMatrix.stCol_1.xZ,&readChar );
fscanf(fInitialPositionsFile,"%s %f %f %f %c", readData,&stSlotMatrix.stTransformMatrix.stCol_2.xX,&stSlotMatrix.stTransformMatrix.stCol_2.xY,&stSlotMatrix.stTransformMatrix.stCol_2.xZ,&readChar );
fscanf(fInitialPositionsFile,"%s %c %f %f %f %c", readData,&readChar,&stSlotMatrix.stTransformMatrix.stCol_0.xX,&stSlotMatrix.stTransformMatrix.stCol_0.xY,&stSlotMatrix.stTransformMatrix.stCol_0.xZ,&readChar );
fscanf(fInitialPositionsFile,"%s %f %f %f %c", readData,&stSlotMatrix.stTransformMatrix.stCol_1.xX,&stSlotMatrix.stTransformMatrix.stCol_1.xY,&stSlotMatrix.stTransformMatrix.stCol_1.xZ,&readChar );
fscanf(fInitialPositionsFile,"%s %f %f %f %c", readData,&stSlotMatrix.stTransformMatrix.stCol_2.xX,&stSlotMatrix.stTransformMatrix.stCol_2.xY,&stSlotMatrix.stTransformMatrix.stCol_2.xZ,&readChar );
//Stefan Dumitrean 2-07-98 ( slots )
fscanf(fInitialPositionsFile,"%s %c %[^\"] %c", readData, &readChar, szNameEditor, &readChar );
fscanf(fInitialPositionsFile,"%s %c %[^\"] %c", readData, &readChar, szNameSelection, &readChar );
//End Stefan Dumitrean 2-07-98 ( slots )
fscanf(fInitialPositionsFile,"%s", readData);
//make a copy of camera
CPA_BaseObject * p_oTempCamera = CopySlotCamera(p_oCamera);
//set new camera matrix
SetMatrix(p_oTempCamera, &stSlotMatrix);
//save camera in slot without copy it
CString csName = szName;
long lSlotNum = p_oSlotCamera->SaveCameraInSlot(p_oSlotCamera->GetSlotNumber(szName), csName, p_oTempCamera, DontMakeACopy);
//Stefan Dumitrean 2-07-98 ( slots )
p_oSlotCamera->SetEditorNameForSlotNr( lSlotNum, szNameEditor );
p_oSlotCamera->SetSelectionNameForSlotNr( lSlotNum, szNameSelection );
//End Stefan Dumitrean 2-07-98 ( slots )
}
fclose(fInitialPositionsFile);
}
else
{
// wsprintf(szName, "Error: could not open %s file !", szName);
// AfxMessageBox( szName, MB_ICONWARNING|MB_OK);
}
}
//***********************************************************************************************
// Method : void Camera_Interface::SaveSlotsPositions()
// Date : 24-03-98
//***********************************************************************************************
// Description :
// Save all non empty slots in an .ECA file
// Parameters:
// Author : Laurentiu Barza
// Modification: Corneliu Babiuc 05-05-98
//***********************************************************************************************
void Camera_Interface::SaveSlotsPositions()
{
FILE * fInitialPositionsFile;
POS_tdstCompletePosition stSlotMatrix;
CPA_CameraSlots * p_oSlotCamera = GetMainWorld()->GetWorld()->GetCameraSlots();
ASSERT(p_oSlotCamera);
char szName[250];
char szBuf[250];
//construct the ECA file name
strcpy(szName, fn_szGetLevelsDataPath());
strcat(szName,"\\");
strcat(szName,fn_p_szGetLevelName());
strcat(szName,"\\");
strcat(szName,fn_p_szGetLevelName());
strcat(szName,".eca");
if((fInitialPositionsFile = fopen(szName, "w")) == NULL)
{
wsprintf(szBuf, "Error: could not open the file %s!", szName);
AfxMessageBox(szBuf, MB_ICONWARNING|MB_OK);
return;
}
for (long lSlotNum = 0; lSlotNum<p_oSlotCamera->GetTotalSlotsNumber(); lSlotNum++)
{
//if slot is empty do nothing
if (p_oSlotCamera->IsEmpty(lSlotNum)) continue;
//Stefan Dumitrean 2-07-98 ( slots )
// do not save reserved slots
if (p_oSlotCamera->IsSlotReserved(lSlotNum)) continue;
/*
//do not save "Copy Of Engine Camera" slot and "Engine Camera Mode"
if ( p_oSlotCamera->GetSlotName(lSlotNum) == "Copy Of Engine Camera" ||
p_oSlotCamera->GetSlotName(lSlotNum) == "Engine Camera Mode")
continue;
*/
//End Stefan Dumitrean 2-07-98 ( slots )
//try to get camera
CPA_BaseObject * p_oCamera = p_oSlotCamera->GetCameraFromSlot(lSlotNum, DontMakeACopy);
if (p_oCamera == NULL) continue;
//get the matrix
POS_fn_vSetIdentityMatrix(&stSlotMatrix);
GetMatrix(p_oCamera, &stSlotMatrix);
//save camera's position
// STM- cameras never have scale, no rotation matrix == transform matrix
fprintf(fInitialPositionsFile,"\n{NameOfCameraSlot: \"%s\"\n", p_oSlotCamera->GetSlotName(lSlotNum));
fprintf(fInitialPositionsFile,"TranslationVector: ( %f %f %f )\n\n",stSlotMatrix.stTranslationVector.xX,stSlotMatrix.stTranslationVector.xY,stSlotMatrix.stTranslationVector.xZ);
fprintf(fInitialPositionsFile,"RotationMatrix: ( %f %f %f )\n",stSlotMatrix.stTransformMatrix.stCol_0.xX,stSlotMatrix.stTransformMatrix.stCol_0.xY,stSlotMatrix.stTransformMatrix.stCol_0.xZ);
fprintf(fInitialPositionsFile," ( %f %f %f )\n",stSlotMatrix.stTransformMatrix.stCol_1.xX,stSlotMatrix.stTransformMatrix.stCol_1.xY,stSlotMatrix.stTransformMatrix.stCol_1.xZ);
fprintf(fInitialPositionsFile," ( %f %f %f )\n\n",stSlotMatrix.stTransformMatrix.stCol_2.xX,stSlotMatrix.stTransformMatrix.stCol_2.xY,stSlotMatrix.stTransformMatrix.stCol_2.xZ);
fprintf(fInitialPositionsFile,"TransformMatrix: ( %f %f %f )\n",stSlotMatrix.stTransformMatrix.stCol_0.xX,stSlotMatrix.stTransformMatrix.stCol_0.xY,stSlotMatrix.stTransformMatrix.stCol_0.xZ);
fprintf(fInitialPositionsFile," ( %f %f %f )\n",stSlotMatrix.stTransformMatrix.stCol_1.xX,stSlotMatrix.stTransformMatrix.stCol_1.xY,stSlotMatrix.stTransformMatrix.stCol_1.xZ);
fprintf(fInitialPositionsFile," ( %f %f %f )\n\n",stSlotMatrix.stTransformMatrix.stCol_2.xX,stSlotMatrix.stTransformMatrix.stCol_2.xY,stSlotMatrix.stTransformMatrix.stCol_2.xZ);
//Stefan Dumitrean 2-07-98 ( slots )
fprintf(fInitialPositionsFile,"EditorName: \"%s\"\n", p_oSlotCamera->GetEditorNameForSlotNr( lSlotNum ) );
fprintf(fInitialPositionsFile,"SelectionName: \"%s\"\n", p_oSlotCamera->GetSelectionNameForSlotNr( lSlotNum ) );
//End Stefan Dumitrean 2-07-98 ( slots )
fprintf(fInitialPositionsFile,"}\n");
}
fclose(fInitialPositionsFile);
}
//END CPA2 Laurentiu Barza 24-03-98
//END CPA2 Corneliu Babiuc 05-05-98
/*=========================================================================*/
/*=========================================================================*/
void Camera_Interface::ChangeCameraTarget()
{
POS_tdstCompletePosition stCameraMatrix;
MTH3D_tdstVector point;
CPA_CameraCoords oCoords;
Camera *p_oCamera;
p_oCamera = (Camera*) GetMainWorld()->GetFRMBase()->m_oGeneralDialogBar.m_p_oCamera;
GetMatrix(p_oCamera, &stCameraMatrix);
point.xX = 0;
point.xY = 0;
point.xZ = GetInterface()->GetCameraTargetDepth();
POS_fn_vMulMatrixVertex(&point, &stCameraMatrix, &point);
oCoords.SetXYZ(point.xX, point.xY, point.xZ);
SetTargetPoint(p_oCamera, &oCoords);
SetTargetType(p_oCamera,tPoint);
Update(p_oCamera);
}
Reference in New Issue View Git Blame Copy Permalink