//*****************************************************************************
//*  _zInterf.inc                                                             *
//*****************************************************************************
//*                                                                           *
//* This file is included by _zInterf.cpp                                     *
//* It contains internal functions of the ZDx_Interface class                 *
//*                                                                           *
//*****************************************************************************
//* Author : Alexis Vaisse                                                    *
//*****************************************************************************


//*****************************************************************************
//                   Personal low-level functions
//*****************************************************************************


//-----------------------------------------------------------------------------
// Class ZDx_Interface - ConvertVectorGlobalToLocal
// Temporary function to convert a vector from the global repere to a local repere
// pSource and pDest must be different
//-----------------------------------------------------------------------------
void ZDx_Interface::ConvertVectorGlobalToLocal (MTH3D_tdstVector * pDest , POS_tdstCompletePosition  * pAbsoluteMatrix , MTH3D_tdstVector * pSource)
{
    // Compute the invert matrix
    POS_tdstCompletePosition  InvMatrix;
    POS_fn_vInvertIsoMatrix(& InvMatrix , pAbsoluteMatrix);

    // Put the translation to 0
    MTH3D_tdstVector NullVector;
    MTH3D_M_vNullVector (& NullVector);
    POS_fn_vSetTranslationVector(& InvMatrix , & NullVector);

    POS_fn_vMulMatrixVertex(pDest , & InvMatrix , pSource);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ConvertVectorLocalToGlobal
// Temporary function to convert a vector from a local repere to the global repere
// pSource and pDest must be different
//-----------------------------------------------------------------------------
void ZDx_Interface::ConvertVectorLocalToGlobal (MTH3D_tdstVector * pDest , POS_tdstCompletePosition  * pAbsoluteMatrix , MTH3D_tdstVector * pSource)
{
    // Keep a copy of the translation vector
    MTH3D_tdstVector BackupTranslation;
    POS_fn_vGetTranslationVector(pAbsoluteMatrix , & BackupTranslation);

    // Put the translation to 0
    MTH3D_tdstVector NullVector;
    MTH3D_M_vNullVector (& NullVector);
    POS_fn_vSetTranslationVector(pAbsoluteMatrix , & NullVector);

    POS_fn_vMulMatrixVertex(pDest , pAbsoluteMatrix , pSource);

    POS_fn_vSetTranslationVector(pAbsoluteMatrix , & BackupTranslation);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ConvertPointGlobalToLocal
// Temporary function to convert a point from the global repere to a local repere
// pSource and pDest must be different
//-----------------------------------------------------------------------------
void ZDx_Interface::ConvertPointGlobalToLocal (MTH3D_tdstVector * pDest , POS_tdstCompletePosition  * pAbsoluteMatrix , MTH3D_tdstVector * pSource)
{
    // Compute the invert matrix
    POS_tdstCompletePosition  InvMatrix;
    POS_fn_vInvertIsoMatrix(& InvMatrix , pAbsoluteMatrix);

    POS_fn_vMulMatrixVertex(pDest , & InvMatrix , pSource);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ConvertPointLocalToGlobal
// Temporary function to convert a point from a local repere to the global repere
// pSource and pDest must be different
//-----------------------------------------------------------------------------
void ZDx_Interface::ConvertPointLocalToGlobal (MTH3D_tdstVector * pDest , POS_tdstCompletePosition  * pAbsoluteMatrix , MTH3D_tdstVector * pSource)
{
    POS_fn_vMulMatrixVertex(pDest , pAbsoluteMatrix , pSource);
}


//*****************************************************************************
//                             Various functions
//*****************************************************************************


//-----------------------------------------------------------------------------
// Class ZDx_Interface - GetZDxTypeName
// return the name ("Zdd"...) of the ZDx type
//-----------------------------------------------------------------------------
char * ZDx_Interface::GetZDxTypeName (tdeZDxType _eZDxType)
{
    switch (_eZDxType)
    {
        case eZdd            : return C_szZddName;
        case eZde            : return C_szZdeName;
        case eZdm            : return C_szZdmName;
        case eZdr            : return C_szZdrName;
        case eBoundingVolume : return C_szBoundingVolumeName;
// ANNECY AV CLEAN_MEC {
//        case eTestPoint      : return C_szTestPointName;
// END ANNECY AV }
        default              : ASSERT (0);
                               return "";
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - GetSelectedActorSuperObject
// Return the selected actor super object. NULL if none
//-----------------------------------------------------------------------------
CPA_SuperObject * ZDx_Interface::GetSelectedActorSuperObject ()
{
    if (M_GetCountSelected () != 1)  return NULL;

    // We look if the selected object is an actor
    CPA_SuperObject * pSelectedSuperObject = M_GetSingleSelection ();
    CPA_BaseObject  * pSelectedObject      = pSelectedSuperObject -> GetObject ();

    if (! pSelectedObject)  return NULL;
    if (pSelectedObject -> fn_bIsOfType (C_szActorInstanceTypeName))  return pSelectedSuperObject;

    // We look if the father is an actor
    pSelectedSuperObject = pSelectedSuperObject -> GetSuperObjectFather ();
    if (! pSelectedSuperObject)  return NULL;

    pSelectedObject = pSelectedSuperObject -> GetObject ();
    if (! pSelectedObject)  return NULL;
    if (pSelectedObject -> fn_bIsOfType (C_szActorInstanceTypeName))  return pSelectedSuperObject;

    return NULL;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ConvertZDxTypeToEngineType
// Convert a ZDx type to a type used by the engine
//-----------------------------------------------------------------------------
unsigned char ZDx_Interface::ConvertZDxTypeToEngineType (tdeZDxType _eZDxType)
{
    switch (_eZDxType)
    {
        case eZdd   : return C_ucTypeZdd;
        case eZde   : return C_ucTypeZde;
        case eZdm   : return C_ucTypeZdm;
        case eZdr   : return C_ucTypeZdr;
        default     : ASSERT (0);
                      return C_ucTypeZdd;
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - GetZDxSuperObject
// Look at all childs of _pParentSuperObject to find the super object
// associated with the given ZDx object
//-----------------------------------------------------------------------------
CPA_SuperObject * ZDx_Interface::GetZDxSuperObject (ZDx_Object * _pZDxObject , CPA_SuperObject * _pParentSuperObject)
{
    CPA_SuperObject * pSuperObject = _pParentSuperObject -> GetSuperObjectFirstChild ();
    while (pSuperObject)
    {
        if (pSuperObject -> GetObject () == _pZDxObject)  return pSuperObject;
        pSuperObject = _pParentSuperObject -> GetSuperObjectNextChild (pSuperObject);
    }

    return NULL;
}


//*****************************************************************************
//                      Personal functions for models
//*****************************************************************************


//-----------------------------------------------------------------------------
// Class ZDx_Interface - AddModelOfZDx
// Add all the models of ZDx into the model window
//-----------------------------------------------------------------------------
void ZDx_Interface::AddModelOfZDx ()
{
    for (int i = 0 ; i < NumberOfZDxModels ; i ++)
    {
        GetInterface () -> fn_bAddANewModel (new EDT_Model
            (this , ListOfZDxModels [i] . szZDxModelName ,
                    ListOfZDxModels [i] . szZDxModelName ,
                    ListOfZDxModels [i] . szBitmapName   , GetInterface()) , C_szZDxListName , this);
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - RemoveModelOfZDx
// Remove all the models of ZDx from the model window
//-----------------------------------------------------------------------------
void ZDx_Interface::RemoveModelOfZDx ()
{
    for (int i = 0 ; i < NumberOfZDxModels ; i ++)
    {
        GetInterface () -> fn_bRemoveAModel (ListOfZDxModels [i] . szZDxModelName , C_szZDxListName);
    }
}


//*****************************************************************************
//                    Personal functions for ZDx creation
//*****************************************************************************


//-----------------------------------------------------------------------------
// Class ZDx_Interface - CreateSuperObject
// Create a super object
//-----------------------------------------------------------------------------
CPA_SuperObject * ZDx_Interface::CreateSuperObject ()
{
    // Create a super object
    CPA_SuperObject * pSuperObject = GetInterface () -> GetNewSuperObject (E_ss_NoSave);

    // Create the matrix of the super object
    HIE_fn_vSetSuperObjectMatrix (pSuperObject -> GetStruct () , (POS_tdstCompletePosition  *) malloc (sizeof (POS_tdstCompletePosition )));
    POS_fn_vSetIdentityMatrix(HIE_fn_hGetSuperObjectMatrix         (pSuperObject -> GetStruct ()));
    pSuperObject -> GetStruct () -> hGlobalMatrix =              (POS_tdstCompletePosition  *) malloc (sizeof (POS_tdstCompletePosition ));
    POS_fn_vSetIdentityMatrix(HIE_fn_hGetSuperObjectGlobalMatrix   (pSuperObject -> GetStruct ()));

    return pSuperObject;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - CreateGraphicObject
// Create a graphic object (sphere, aligned box...)
// Return a Geometry3D object and a handle to the element
//-----------------------------------------------------------------------------
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)

Shape3D * ZDx_Interface::CreateGraphicObject (tdeZDxGeometricType _eZDxGeometricType /*, ACP_tdxHandleOfElement * _pHandle */,
                                                 char * _szDataPath , const CString _csReferenceSectionName)
{
    // Get the owner of the geometric object which is a CPA_BaseObject associated with the file name
    CPA_DLLBase         * pOgdDll    = GetMainWorld () -> GetObjectDLLWithName (C_szDLLGeometryName);
    ASSERT (pOgdDll);
    CString csCompleteName  = _szDataPath;
            csCompleteName += "\\" + _csReferenceSectionName;
    CPA_FileObject      * pOwnerFile = GetInterface () -> GetFileObject (csCompleteName);

    tdeSaveStatus   eSaveStatus = _csReferenceSectionName . IsEmpty () ? E_ss_NoSave : E_ss_Responsible;
    Shape3D    * pGeometric3dObject;

    switch (_eZDxGeometricType)
    {
    case eSphere:   {
					/*
                    pGeometric3dObject = new Geometry3D (pOgdDll , 1 , 1, pOwnerFile , "" , _szDataPath , eSaveStatus);  // 1 point, 1 element
                    MTH3D_tdstVector stCenterPoint = { 0 , 0 , 0 };
                    pGeometric3dObject -> fn_vSetListOfPoints  (1 , & stCenterPoint);
                    * _pHandle         =  pGeometric3dObject -> fn_hCreateElementSpheres (1);
                    pGeometric3dObject -> fn_eSetIndexedSphere (* _pHandle , 0 , 0 , (float) 0.1);
					*/
					pGeometric3dObject = new Sphere3D (TRUE, pOgdDll, pOwnerFile , "" , _szDataPath , eSaveStatus);
					
					}
                    break;

    case eBox:      {
					/*
                    pGeometric3dObject = new Geometry3D (pOgdDll , 2 , 1, pOwnerFile , "" , _szDataPath , eSaveStatus);  // 2 points, 1 element
                    MTH3D_tdstVector stMinMaxPoints [2] = {{ (float) -0.1 , (float) -0.1 , (float) -0.1 } ,
                                                           { (float)  0.1 , (float)  0.1 , (float)  0.1 }};
                    pGeometric3dObject -> fn_vSetListOfPoints (2 , stMinMaxPoints);
                    * _pHandle         =  pGeometric3dObject -> fn_hCreateElementAlignedBox (1);
                    pGeometric3dObject -> fn_eSetAlignedBox   (* _pHandle, 0 , 0 , 1);
					*/
					pGeometric3dObject = new Box3D (TRUE, pOgdDll, pOwnerFile , "" , _szDataPath , eSaveStatus);
                    }
                    break;

    case ePoint:    {
					/*
                    pGeometric3dObject = new Geometry3D (pOgdDll , 1 , 1, pOwnerFile , "" , _szDataPath , eSaveStatus);  // 1 point, 1 element
                    MTH3D_tdstVector stPoint = { 0 , 0 , 0 };
                    pGeometric3dObject -> fn_vSetListOfPoints (1 , & stPoint);
                    * _pHandle         = pGeometric3dObject -> fn_hCreateElementPoints (1);
                    pGeometric3dObject -> fn_eSetIndexedPoint (* _pHandle , 0 , 0);
                    pGeometric3dObject -> fn_eSetFatnessOfElementPoint  (* _pHandle , (float) 8.0);

					*/
					pGeometric3dObject = new Point3D (pOgdDll, pOwnerFile , "" , _szDataPath , eSaveStatus);
                    }
                    break;

    case eCone:     {
					/*
                    pGeometric3dObject = new Geometry3D (pOgdDll , 2 , 1, pOwnerFile , "" , _szDataPath , eSaveStatus);  // 2 points, 1 element
                    MTH3D_tdstVector stPoints [2] = {{ 0 , 0 , 0 } , { 0 , 0 , 1 }};
                    pGeometric3dObject -> fn_vSetListOfPoints (2 , stPoints);
                    * _pHandle         = pGeometric3dObject -> fn_hCreateElementCone (1);
                    pGeometric3dObject -> fn_eSetCone         (* _pHandle , 0 , 0 , 1 , (float) 0.1);
					*/

					pGeometric3dObject = new Cone3D (TRUE, pOgdDll, pOwnerFile , "" , _szDataPath , eSaveStatus);
                    }
                    break;

    default:        ASSERT (0);    break;
    }
    //pGeometric3dObject -> fn_vEndCreation ();
    pGeometric3dObject -> fn_vEndCreation ();
	pGeometric3dObject -> fn_vAllocAndComputeListOfPointsMaterial ();

    return pGeometric3dObject;

//ENDROMTEAM WorldEditor (Cristi Petrescu)
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - CreateGraphicSuperObject
// Create a graphic super object (sphere, aligned box...)
// Return a super object and a handle to the element
//-----------------------------------------------------------------------------
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)

CPA_SuperObject * ZDx_Interface::CreateGraphicSuperObject (tdeZDxGeometricType _eZDxGeometricType /*, ACP_tdxHandleOfElement * pHandle */,
                                                           char * _szDataPath , const CString _csReferenceSectionName)
{
    CPA_SuperObject * pSuperObject       = CreateSuperObject   ();
    Shape3D			* pGeometric3dObject = CreateGraphicObject (_eZDxGeometricType /*, pHandle */, _szDataPath , _csReferenceSectionName);

    pSuperObject       -> SetObject                  (pGeometric3dObject);
    pSuperObject       -> SetTypeSO                  (C_Protected);

	pGeometric3dObject->SetSuperObject (pSuperObject);

    return pSuperObject;

//ENDROMTEAM WorldEditor (Cristi Petrescu)
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - GetFamilyForNewInstance
// Give the family of a new created ZDx object
//-----------------------------------------------------------------------------
CPA_BaseObject * ZDx_Interface::GetFamilyForNewInstance (CPA_BaseObject * _pParent)
{
    // We find the family of the actor
    CPA_BaseObject * pActor;
    if (m_pList1Window -> IsEditingZDxOfModule ())  pActor = m_pList1Window -> GetSelectedActor(); // ZDx of module : we get the parent from the List1Window
                                              else  pActor = _pParent;                             // ZDx of actor  : the actor is the parent
    ASSERT (pActor);
    CPA_BaseObject * pModel  = pActor  -> GetOwner  ();
    ASSERT (pModel);
    CPA_BaseObject * pFamily = pModel  -> GetOwner  ();
    ASSERT (pFamily);

    return pFamily;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ComputeSectionNameForNewInstance
// Compute the data path and the reference section name to give to a created ZDx object
//-----------------------------------------------------------------------------
void ZDx_Interface::ComputeSectionNameForNewInstance (char * * _p_szDataPath , CString * _p_csReferenceSectionName ,
                                                      CPA_BaseObject * _pParent)
{
    CPA_BaseObject * pFamily = GetFamilyForNewInstance (_pParent);

    * _p_szDataPath = fn_szGetLevelsDataPath ();

// ANNECY AV CLEAN_MEC {
/*
    if (m_pList1Window -> IsEditingTestPoint ())    // ZDx object that are test points are not saved
    {
        * _p_csReferenceSectionName = "";
        return;
    }
*/
// END ANNECY AV }

    if (m_pList1Window -> IsEditingBoundingVolume ())    // Set the file name for the bounding volume
    {
         * _p_csReferenceSectionName = "_Common\\Families\\" + pFamily -> GetName () + "\\" + pFamily -> GetName () + C_szBoundingVolumeFileExtension;
         return;
    }

    if (m_pList1Window -> IsEditingZDxOfModule ())       // Zone of module
    {
         CPA_BaseObject * pObjectTable = _pParent -> GetOwner ();
         ASSERT (pObjectTable);
         CString csObjectTableName = pObjectTable -> GetName ();
         int PosPoint = csObjectTableName . Find ('.');
         if (PosPoint != -1)  csObjectTableName = csObjectTableName . Left (PosPoint);
         * _p_csReferenceSectionName = pFamily -> GetName () + "\\" + csObjectTableName + C_szModuleZDxFileExtension;
         * _p_szDataPath = fn_szGetFamiliesDataPath ();
    }
    else                                                 // Set the file name for a zone of actor
    {
        // We get the selected position in the list 2, and we check if it is empty
        tdeZDxType eZDxType;
        long       lPosition;
        if (m_pList2Window -> GetSelectedZDx (& eZDxType , & lPosition) != NULL || lPosition == -1)
        {
            // if not, we select an empty position
            m_pList2Window -> SelectZDx (NULL , TRUE);
            m_pList2Window -> GetSelectedZDx (& eZDxType , & lPosition);
        }
        // Get the name list
        CPA_tdoNameList * pNameList = GetNameList (_pParent , eZDxType);
        // Get the name associated to the ZDx object to insert
        POSITION          Pos = pNameList -> GetHeadPosition ();
        tdoObjectName   * pName;
        while (lPosition-- >= 0)
            pName = pNameList -> GetNext (Pos);

        if (pName -> m_eGetShareMode () == E_sm_Virge)       // Specific name
        {
            char szTmp [SCR_CV_ui_Cfg_MaxLenName];
            fn_zsGetActualLevelFilename (szTmp , "");        // szSectionName = "GameData\Level\Cave\Cave."
            char * p = strrchr (szTmp , '.');
            if (p)  * p = 0;                                 // If there is a '.' at the end of the name, remove it
            p = strrchr (szTmp , '\\') + 1;                   // p             = "Cave"

            * _p_csReferenceSectionName  = p;
            * _p_csReferenceSectionName += "\\Families\\" + pFamily -> GetName () + "\\" + pFamily -> GetName () + C_szActorZDxFileExtension;
        }
        else
        {
            * _p_csReferenceSectionName = "_Common\\Families\\" + pFamily -> GetName () + "\\" + pFamily -> GetName () + C_szActorZDxFileExtension;
        }
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - GetNewInstanceWithSameZDxObject
// Same function as GetNewInstance, but use an existing ZDx object
//-----------------------------------------------------------------------------
CPA_SuperObject * ZDx_Interface::GetNewInstanceWithSameZDxObject (ZDx_Object * pZDxObject , 
                                                                  char       * szZDxGeometricTypeName)
{
    // Create a super object for the graphic object
    CPA_SuperObject * pGraphicSuperObject = CreateSuperObject ();

//ANNECY TQ 29/04/98{
	if(pZDxObject -> GetZDxType () == eZdm)
		pGraphicSuperObject -> fn_vHasALinkedZDM(TRUE);
	else
		pGraphicSuperObject -> fn_vHasALinkedZDM(FALSE);
//ENDANNECY TQ}

	HIE_fn_vSetSuperObjectTransparenceLevel(pGraphicSuperObject->GetStruct(), 100);

    // Create a super object
    CPA_SuperObject * pSuperObject = CreateSuperObject ();

    // Give it the graphic super object as child
    pGraphicSuperObject -> SetEditProtected (TRUE);                  // So the user cannot move it
    pGraphicSuperObject -> SetSuperObjectOwner (pSuperObject);
    pSuperObject -> AddTail (pGraphicSuperObject);

    // set the model name of the super object
    pSuperObject -> SetModelName (szZDxGeometricTypeName);

    // Give the graphic object of the ZDx object to the graphic super object
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
    Shape3D * pGeometric3dObject = pZDxObject -> GetZDxShape () -> GetGeometric3dObject ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
   pGraphicSuperObject -> SetObject      (pGeometric3dObject);

    // Give the ZDx object to the super object
    pSuperObject -> SetObject      (pZDxObject);

    // Set the type of the super object and the graphic super object
    pSuperObject        -> SetTypeSO (C_Protected);
    pGraphicSuperObject -> SetTypeSO (C_Protected);

//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
	pGeometric3dObject -> SetSuperObject (pGraphicSuperObject);
//ENDROMTEAM WorldEditor (Cristi Petrescu)

    return pSuperObject;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - CreateZdxObject
// Create a new Zdx with an existing engine zone (no NotifySave because it is for loading)
//-----------------------------------------------------------------------------
ZDx_Object * ZDx_Interface::CreateZdxObject (LPARAM lParam)
{
    tdstCreateZoneMess * p_stCreateZoneMess = (tdstCreateZoneMess *) lParam;

    CString               csTypeName              = p_stCreateZoneMess -> csTypeName;
    ACP_tdxHandleOfObject hEngineZone             = (ACP_tdxHandleOfObject) p_stCreateZoneMess -> hEngineZone;
    CString               csZDxName               = p_stCreateZoneMess -> csName;
    CPA_BaseObject      * pOwner                  = p_stCreateZoneMess -> pOwner;
    char *                szDataPath              = p_stCreateZoneMess -> szDataPath;
    CString               csReferenceSectionName  = p_stCreateZoneMess -> csReferenceSectionName;
    if (csReferenceSectionName . Find (SCR_CC_sz_Cfg_NameSeparator) == -1)
        csReferenceSectionName += SCR_CC_sz_Cfg_NameSeparator;

    tdeZDxType eZDxType = ConvertListTypeToZDxType (csTypeName);

    // We check if there is already a ZDx object with this engine zone
    ZDx_Object * pExistingZDxObject = (ZDx_Object *) GetMainWorld () -> fn_p_oFindObjectWithEngine (hEngineZone , csTypeName);
    if (pExistingZDxObject)  return pExistingZDxObject;

    // Compute the ZDx geometric type
    tdeZDxGeometricType eZDxGeometricType;
    switch (GEO_xGetElementType (hEngineZone , 0))
    {
        case GEO_C_xElementSpheres			: eZDxGeometricType = eSphere;  break;
        case GEO_C_xElementAlignedBoxes		: eZDxGeometricType = eBox;     break;
        case GEO_C_xElementPoints			: eZDxGeometricType = ePoint;   break;
        case GEO_C_xElementCones			: eZDxGeometricType = eCone;    break;
        default								: {   // The object has itself or another PO as Zdr
                                                  CPA_BaseObjectList * pPoList = GetMainWorld () -> fn_p_oGetOriginalObjectList	(C_szPhysicalObjectTypeName);
                                                  ASSERT (pPoList);

                                                  Position             Pos     = pPoList -> GetHeadPosition ();
                                                  while (Pos)
                                                  {
                                                      EditorPO   * pPo              = (EditorPO *) pPoList -> GetNext (Pos);
                                                      Geometry3D * pGeometricObject = pPo -> m_fnp_oGetGeometricWithDistance (0);
                                                      if (pGeometricObject && pGeometricObject -> GetData () == hEngineZone)
                                                          return (ZDx_Object *) pPo;
                                                  }

                                                  return NULL;    // Not found
                                              }
    }

    // Create the geometric 3d object
    char szShortFileName [SCR_CV_ui_Cfg_MaxLenName];
    SCR_fn_v_RdL0_SplitSectionName ( (char *) (LPCTSTR) csReferenceSectionName , szShortFileName , NULL , NULL);

    CPA_DLLBase * pOgdDll = GetMainWorld () -> GetObjectDLLWithName (C_szDLLGeometryName);
    ASSERT (pOgdDll );
    CString csCompleteName = szDataPath;
    csCompleteName        += "\\";
    csCompleteName        += szShortFileName;
    CPA_FileObject * pOwnerFile = GetInterface () -> GetFileObject (csCompleteName);

//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
	// create the right geom object
	Shape3D * pGeometric3dObject;
	switch (eZDxGeometricType)
	{
		case	eSphere:
			pGeometric3dObject = new Sphere3D (TRUE, pOgdDll , pOwnerFile , hEngineZone , csZDxName , szDataPath , E_ss_Responsible);
			break;
		case	eBox:
			pGeometric3dObject = new Box3D (TRUE, pOgdDll , pOwnerFile , hEngineZone , csZDxName , szDataPath , E_ss_Responsible);
			break;
		case	eCone:
			pGeometric3dObject = new Cone3D (TRUE, pOgdDll , pOwnerFile , hEngineZone , csZDxName , szDataPath , E_ss_Responsible);
			break;
		case	ePoint:
			pGeometric3dObject = new Point3D (pOgdDll , pOwnerFile , hEngineZone , csZDxName , szDataPath , E_ss_Responsible);
			break;
		default:
			ASSERT (FALSE);
			//pGeometric3dObject = new Shape3D (TRUE, pOgdDll , pOwnerFile , hEngineZone , csZDxName , szDataPath , E_ss_Responsible);
	}

    // Create the ZDx object
    ZDx_Object * pNewZDxObject = new ZDx_Object (this , csTypeName , eZDxType , eZDxGeometricType , csZDxName , 
                                                 pOwner , pGeometric3dObject /*, 0*/);
 //ENDROMTEAM WorldEditor (Cristi Petrescu)
   return pNewZDxObject;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - CreateZdxTestPoints
// For each test point in the given list, create an associated ZDx object
//-----------------------------------------------------------------------------
// ANNECY AV CLEAN_MEC {
/*
void ZDx_Interface::CreateZdxTestPoints (CPA_TestPointsList * _pTestPointList)
{
    // Get the Geometry dll
    CPA_DLLBase * pOgdDll = GetMainWorld () -> GetObjectDLLWithName (C_szDLLGeometryName);
    ASSERT (pOgdDll );

    POSITION Pos = _pTestPointList -> m_oListOfTestPoints . GetHeadPosition ();
    while (Pos)
    {
        // We get one Test Point from the list
        CPA_TestPointNode * pTestPoint = _pTestPointList -> m_oListOfTestPoints . GetNext (Pos);

//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
        // Create the geometric 3d object
//        Shape3D * pGeometric3dObject = new Shape3D (TRUE, pOgdDll , 1 , 1);
//        MTH3D_tdstVector stPoint;
//        pTestPoint         -> mfn_vGetPosition (& stPoint);
//        pGeometric3dObject -> fn_vSetListOfPoints  (1 , & stPoint);
//        ACP_tdxHandleOfElement hHandleOfElement = pGeometric3dObject -> fn_hCreateElementPoints (1);
//        pGeometric3dObject -> fn_eSetIndexedPoint           (hHandleOfElement , 0 , 0);
//        pGeometric3dObject -> fn_eSetFatnessOfElementPoint  (hHandleOfElement , (float) 8.0);

		Point3D * pGeometric3dObject = new Point3D (pOgdDll);
		MTH3D_tdstVector stPoint;
        pTestPoint -> mfn_vGetPosition (& stPoint);
		pGeometric3dObject -> SetPoint (& stPoint);
		//never true!
		//if (m_pZDxObject -> GetZDxType () == eTestPoint)  UpdateTestPointPosition ();

        // Create the ZDx object
        ZDx_Object * pNewZDxObject = new ZDx_Object (this , C_szTestPointName , eTestPoint , ePoint , "" , NULL , pGeometric3dObject ); //, hHandleOfElement);

//ENDROMTEAM WorldEditor (Cristi Petrescu)
        // Give the created ZDx object to the test point
        pTestPoint    -> SetZdxObject (pNewZDxObject);
        pNewZDxObject -> SetTestPoint (pTestPoint);
    }
}
*/
// END ANNECY AV }

//*****************************************************************************
//                  Communication with hierarchy editor
//*****************************************************************************


//-----------------------------------------------------------------------------
// Class ZDx_Interface - AskHierarchyEditorToSelectObject
// Ask the hierarchy editor to select an object (NULL to cancel the selection)
//-----------------------------------------------------------------------------
void ZDx_Interface::AskHierarchyEditorToSelectObject (CPA_SuperObject * _pSuperObject)
{
    if (m_bIsSelectingObject)  return;

    m_bIsAskingToSelectObject = TRUE;

    GetInterface () -> fn_vCancelCurrentSelection (FALSE);
    if (_pSuperObject)  GetInterface () -> fn_vAddSelectedObject (_pSuperObject , FALSE);

    m_bIsAskingToSelectObject = FALSE;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - InsertZDxObjectIntoHierarchy
// Ask the hierarchy editor to insert a ZDx object into the hierarchy
//-----------------------------------------------------------------------------
void ZDx_Interface::InsertZDxObjectIntoHierarchy (CPA_SuperObject * _pZDxSuperObject , CPA_SuperObject * _pParentSuperObject)
{
    m_bIsInsertingZDxObject = TRUE;

    GetInterface () -> fn_bInsertObjectInHierarchy (_pZDxSuperObject , _pParentSuperObject , FALSE , FALSE);

    m_bIsInsertingZDxObject = FALSE;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - DeleteZDxObjectFromHierarchy
// Ask the hierarchy editor to delete a ZDx object from the hierarchy
//-----------------------------------------------------------------------------
void ZDx_Interface::DeleteZDxObjectFromHierarchy (CPA_SuperObject * _pZDxSuperObject)
{
    m_bIsDeletingZDxObject = TRUE;

    // We call the hierarchy editor to delete the ZDx super object from the hierarchy
    GetInterface () -> fn_bDeleteObjectInHierarchy (_pZDxSuperObject , FALSE , FALSE);

    m_bIsDeletingZDxObject = FALSE;
}


//*****************************************************************************
//                         Show / Hide ZDx objects
//*****************************************************************************


//-----------------------------------------------------------------------------
// Class ZDx_Interface - SetDisplayFlag
// Set the display flag of all ZDx of the list
//-----------------------------------------------------------------------------
void ZDx_Interface::SetDisplayFlag (EdtList * _pListOfZDx , tdeZDxDisplayType _eDisplayType)
{
    POSITION PosZDx = _pListOfZDx -> GetHeadPosition();
    while (PosZDx)
    {
        ZDx_Object * pZDxObject = (ZDx_Object *) _pListOfZDx -> GetNext (PosZDx);
        if (pZDxObject)  pZDxObject -> SetDisplay (_eDisplayType);
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - SetDisplayFlag
// Set the display zone flag of all test points of the list
//-----------------------------------------------------------------------------
// ANNECY AV CLEAN_MEC {
/*
void ZDx_Interface::SetDisplayFlag (CPA_TestPointsList * _pListOfTestPoint , tdeZDxDisplayType _eDisplayType)
{
    POSITION Pos = _pListOfTestPoint -> m_oListOfTestPoints . GetHeadPosition ();
    while (Pos)
    {
        CPA_TestPointNode * pTestPoint = _pListOfTestPoint -> m_oListOfTestPoints . GetNext (Pos);
        ASSERT (pTestPoint);

        ZDx_Object        * pZDxObject = pTestPoint -> mfn_p_oGetZdxObject ();
        ASSERT (pZDxObject);

        pZDxObject -> SetDisplay (_eDisplayType);
    }
}
*/
// END ANNECY AV }

//-----------------------------------------------------------------------------
// class ZDx_Interface - SetDisplayFlagOfAllActors
// Set the display zone flag of all actors
//-----------------------------------------------------------------------------
void ZDx_Interface::SetDisplayFlagOfAllActors (BOOL _bNewFlag)
{
    CPA_BaseObjectList * pListOfActor = GetMainWorld () -> fn_p_oGetOriginalObjectList (C_szActorInstanceTypeName);

    for (int i = 0 ; i < pListOfActor -> GetCount () ; i ++)
    {
        CPA_Actor * pActor = (CPA_Actor *) pListOfActor -> GetObjectWithIndex (i);
        pActor -> SetDisplayZone (_bNewFlag);
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - SetAspectOfZDx
// Set the graphical aspect of a ZDx : selected or not selected
//-----------------------------------------------------------------------------
void ZDx_Interface::SetAspectOfZDx (CPA_SuperObject * _pSuperObject , BOOL _bSelected)
{
    // Sometimes, _pSuperObject can be NULL, because we try to set the aspect of a ZDx object which is not shown
    if (_pSuperObject == NULL)  return;

//    long lDrawMask = _bSelected ? 0                    // Wired
//                                : C_lGouraudElement;   // Gouraud

    long lDrawMask = 0x4ddc037e; //Gouraud with Outline and Wire

    HIE_fn_vSetSuperObjectDrawMask (_pSuperObject -> GetStruct () , lDrawMask);

    // Special treatment for the points
    ZDx_Object * pZDxObject = (ZDx_Object *) _pSuperObject -> GetObject ();
    if (pZDxObject && pZDxObject -> GetZDxGeometricType () == ePoint)
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
        ((Point3D *)((ZDx_Point *) pZDxObject -> GetZDxShape ()) -> GetGeometric3dObject ()) -> SetColorOfPoint (_bSelected);
//ENDROMTEAM WorldEditor (Cristi Petrescu)

   // We also change the draw mask of the actor for the zones to be showed
    CPA_SuperObject * pParent = _pSuperObject -> GetSuperObjectFather ();
    if (pParent)  HIE_fn_vSetSuperObjectDrawMask (pParent -> GetStruct () , 
											      GLI_C_lAllIsEnable ^ GLI_C_lIsNotDrawCollideInformation);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - PutZDxIntoHierarchy
// Put a ZDx as child of a super object into the hierarchy
//-----------------------------------------------------------------------------
void ZDx_Interface::PutZDxIntoHierarchy (CPA_SuperObject * _pFatherSuperObject , 
                                         ZDx_Object      * _pZDxObject         ,
                                         BOOL              _bSelectZDx         ,
                                         BOOL              _bSetEditProtected /* = FALSE */)
{
    char * szGeometricTypeName;
    switch (_pZDxObject -> GetZDxGeometricType ())
    {
        case eSphere :  szGeometricTypeName = C_szZDxSphereName;    break;
        case eBox    :  szGeometricTypeName = C_szZDxBoxName;       break;
        case ePoint  :  szGeometricTypeName = C_szZDxPointName;     break;
        case eCone   :  szGeometricTypeName = C_szZDxConeName;      break;
        default:        ASSERT (0);                                 break;
    }

    CPA_SuperObject * pSuperObject = GetNewInstanceWithSameZDxObject (_pZDxObject , szGeometricTypeName);
    pSuperObject -> SetEditProtected (_bSetEditProtected);

    GetInterface () -> fn_bInsertObjectInHierarchy (pSuperObject , _pFatherSuperObject , FALSE , FALSE, FALSE);
    SetAspectOfZDx  (pSuperObject , _bSelectZDx);    // must be called when the ZDx has a father
    _pZDxObject -> SetDisplay (eDisplayed);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - CheckAndPutZDxIntoHierarchy
// Check if the ZDx must be put into the hierarchy
//-----------------------------------------------------------------------------
void ZDx_Interface::CheckAndPutZDxIntoHierarchy (CPA_SuperObject * _pFatherSuperObject ,
                                                 ZDx_Object      * _pZDxObject         ,
                                                 BOOL              _bSelectZDx         ,
                                                 BOOL              _bSetEditProtected /* = FALSE */)
{
    if (_pZDxObject == NULL)  return;
    switch (_pZDxObject -> GetDisplay ())
    {
        case eNotDisplayed         : PutZDxIntoHierarchy (_pFatherSuperObject , _pZDxObject , _bSelectZDx , _bSetEditProtected);
                                     break;

        case eDisplayed            : {
                                     //??? A FAIRE CORRECTEMENT PLUS TARD CAR METHODE TROP LENTE
                                     CPA_SuperObject * pZDxSuperObject = GetZDxSuperObject (_pZDxObject , _pFatherSuperObject);
                                     SetAspectOfZDx (pZDxSuperObject , _bSelectZDx);
                                     }
                                     break;

        default                    : ASSERT (0);
                                     break;
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - PutListOfZDxIntoHierarchy
// Put a list of ZDx as childs of a super object into the hierarchy
//-----------------------------------------------------------------------------
void ZDx_Interface::PutListOfZDxIntoHierarchy (EdtList         * _pListOfZDx ,
                                               CPA_SuperObject * _pFatherSuperObject ,
                                               ZDx_Object      * _pZDxObjectToSelect ,
                                               BOOL              _bUseDisplayFlag    ,
                                               BOOL              _bSetEditProtected /* = FALSE */)
{
    POSITION PosZDx = _pListOfZDx -> GetHeadPosition ();
    while (PosZDx)
    {
        ZDx_Object * pZDxObject = (ZDx_Object *) _pListOfZDx -> GetNext (PosZDx);
        if (_bUseDisplayFlag && pZDxObject && pZDxObject -> GetMotorDisplay () == FALSE && pZDxObject != _pZDxObjectToSelect)
            continue;

        CheckAndPutZDxIntoHierarchy (_pFatherSuperObject , pZDxObject , pZDxObject == _pZDxObjectToSelect , _bSetEditProtected);
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - PutListOfTestPointIntoHierarchy
// Put a list of test points as childs of a super object into the hierarchy
//-----------------------------------------------------------------------------
// ANNECY AV CLEAN_MEC {
/*
void ZDx_Interface::PutListOfTestPointIntoHierarchy (CPA_TestPointsList * _pListOfTestPoint ,
                                                     CPA_SuperObject    * _pFatherSuperObject ,
                                                     ZDx_Object         * _pZDxObjectToSelect ,
                                                     BOOL                 _bUseDisplayFlag    ,
                                                     BOOL                 _bSetEditProtected)
{
    POSITION Pos = _pListOfTestPoint -> m_oListOfTestPoints . GetHeadPosition ();
    while (Pos)
    {
        CPA_TestPointNode * pTestPoint = _pListOfTestPoint -> m_oListOfTestPoints . GetNext (Pos);
        ZDx_Object        * pZDxObject = pTestPoint -> mfn_p_oGetZdxObject ();
        if (_bUseDisplayFlag && pZDxObject && pZDxObject -> GetMotorDisplay () == FALSE)  continue;

        CheckAndPutZDxIntoHierarchy (_pFatherSuperObject , pZDxObject , pZDxObject == _pZDxObjectToSelect , _bSetEditProtected);
    }
}
*/
// END ANNECY AV }

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ShowZDxOfActor
// Show the ZDx of a instance (insert ZDx objects in the hierarchy)
// Return TRUE if something has been modified
//-----------------------------------------------------------------------------
void ZDx_Interface::ShowZDxOfActor (CPA_SuperObject * _pActorSuperObject , unsigned char _ucZDxToShow ,
                                    ZDx_Object      * _pZDxToSelect      /* = NULL  */ ,
                                    BOOL              _bUseDisplayFlag   /* = TRUE  */ ,
                                    BOOL              _bSetEditProtected /* = FALSE */)
{
    CPA_BaseObject * pActor = _pActorSuperObject -> GetObject ();

    if (m_pActorSuperObjectToUnselect && m_pActorSuperObjectToUnselect != _pActorSuperObject)    // One actor to unselect
    {
        CPA_Actor * pActorToUnselect = (CPA_Actor *) m_pActorSuperObjectToUnselect -> GetObject ();
        unsigned char ucZDxToShow;
        tdeDisplayType eDisplayForAllActors = m_pDisplayControlWindow -> GetDisplayForAllActors ();
        switch (eDisplayForAllActors)
        {
            case eNoZone     :
            case eOff      : ucZDxToShow = C_ucHideAllZDx;    break;
            case eOn       : ucZDxToShow = C_ucShowAllZDx;    break;
            case eSelected : if (pActorToUnselect -> GetDisplayZone ())  ucZDxToShow = C_ucShowAllZDx;
                                                                   else  ucZDxToShow = C_ucHideAllZDx;
                             break;
        }
        ShowZDxOfActor (m_pActorSuperObjectToUnselect , ucZDxToShow , NULL ,
                        eDisplayForAllActors == eSelected ? (int) pActorToUnselect -> GetDisplayZone () == 2 : FALSE);
        HideModuleZDxOfActor (m_pActorSuperObjectToUnselect);
        m_pActorSuperObjectToUnselect = NULL;
    }

    m_bIsShowingOrHidingZDx = TRUE;

    BOOL bShowZdd       = (_ucZDxToShow & C_ucShowZDD)       != 0;
    BOOL bShowZde       = (_ucZDxToShow & C_ucShowZDE)       != 0;
    BOOL bShowZdm       = (_ucZDxToShow & C_ucShowZDM)       != 0;
    BOOL bShowZdr       = (_ucZDxToShow & C_ucShowZDR)       != 0;
// ANNECY AV CLEAN_MEC {
//    BOOL bShowTestPoint = (_ucZDxToShow & C_ucShowTestPoint) != 0;
// END ANNECY AV }

    // Set all display flags to eNotDisplayed
    EdtList            * pListOfZdd       = GetZDxList (pActor , eZdd);
    EdtList            * pListOfZde       = GetZDxList (pActor , eZde);
    EdtList            * pListOfZdm       = GetZDxList (pActor , eZdm);
    EdtList            * pListOfZdr       = GetZDxList (pActor , eZdr);
// ANNECY AV CLEAN_MEC {
//    CPA_TestPointsList * pListOfTestPoint = NULL;
//    if (m_pList1Window -> IsEditingTestPoint ()) pListOfTestPoint = m_pList2Window -> GetListOfTestPoint ();
// END ANNECY AV }

    if (pListOfZdd      )  SetDisplayFlag (pListOfZdd       , eNotDisplayed);
    if (pListOfZde      )  SetDisplayFlag (pListOfZde       , eNotDisplayed);
    if (pListOfZdm      )  SetDisplayFlag (pListOfZdm       , eNotDisplayed);
    if (pListOfZdr      )  SetDisplayFlag (pListOfZdr       , eNotDisplayed);
// ANNECY AV CLEAN_MEC {
//    if (pListOfTestPoint)  SetDisplayFlag (pListOfTestPoint , eNotDisplayed);
// END ANNECY AV }

    // We look for all ZDx child of the actors :
    // For each ZDx, we set its Display flag, and we remove it from the hierarchy if it must not be shown
    CPA_SuperObject * pSuperObject =  _pActorSuperObject -> GetSuperObjectFirstChild ();
    CPA_SuperObject * pNextChild;
    while (pSuperObject)
    {
        pNextChild = _pActorSuperObject -> GetSuperObjectNextChild (pSuperObject);

        // No object or not a ZDx -> go to the next child
        CPA_BaseObject * pObject = pSuperObject -> GetObject ();
        if (pObject == NULL || ! M_bIsThisObjectAZDx (pObject))
        {
            pSuperObject = pNextChild;
            continue;
        }

        ZDx_Object * pZDxObject  = (ZDx_Object *) pObject;
        long         lEngineType = pZDxObject -> GetDataType ();

        if (!m_pList1Window -> IsEditingBoundingVolume() && 
		   ((lEngineType == C_lZDD       && ! bShowZdd)    // if the ZDx must not be shown
         || (lEngineType == C_lZDE       && ! bShowZde)
         || (lEngineType == C_lZDM       && ! bShowZdm)
         || (lEngineType == C_lZDR       && ! bShowZdr)
         || (lEngineType == C_lBoundingVolume)
// ANNECY AV CLEAN_MEC {
//         || (lEngineType == C_lTestPoint && ! bShowTestPoint)
// END ANNECY AV }
         || (_bUseDisplayFlag            && pZDxObject -> GetMotorDisplay () == FALSE && pZDxObject != _pZDxToSelect))
		 )
        {
            pZDxObject -> SetDisplay (eNotDisplayed);

            // Remove the object from the hierarchy
            GetInterface () -> fn_bDeleteObjectInHierarchy (pSuperObject , FALSE , FALSE);
        }
        else
        {
            pZDxObject -> SetDisplay (eDisplayed);
            SetAspectOfZDx (pSuperObject , pZDxObject == _pZDxToSelect);
            pSuperObject -> SetEditProtected (_bSetEditProtected);
        }

        pSuperObject = pNextChild;
    }

    if (bShowZdd && pListOfZdd)
        PutListOfZDxIntoHierarchy (pListOfZdd , _pActorSuperObject , _pZDxToSelect , _bUseDisplayFlag , _bSetEditProtected);

    if (bShowZde && pListOfZde)
        PutListOfZDxIntoHierarchy (pListOfZde , _pActorSuperObject , _pZDxToSelect , _bUseDisplayFlag , _bSetEditProtected);

    if (bShowZdm && pListOfZdm)
        PutListOfZDxIntoHierarchy (pListOfZdm , _pActorSuperObject , _pZDxToSelect , _bUseDisplayFlag , _bSetEditProtected);

    if (bShowZdr && pListOfZdr)
        PutListOfZDxIntoHierarchy (pListOfZdr , _pActorSuperObject , _pZDxToSelect , _bUseDisplayFlag , _bSetEditProtected);

// ANNECY AV CLEAN_MEC {
//    if (bShowTestPoint && pListOfTestPoint)
//        PutListOfTestPointIntoHierarchy (pListOfTestPoint , _pActorSuperObject , _pZDxToSelect , _bUseDisplayFlag , _bSetEditProtected);
// END ANNECY AV }

    // If there is a ZDx object to select, we select it
    if (_pZDxToSelect && ((GetInterface()->GetSelectMode() == "All Types")  || (GetInterface()->GetSelectMode() == C_szZddName)
																			|| (GetInterface()->GetSelectMode() == C_szZdeName)
																			|| (GetInterface()->GetSelectMode() == C_szZdmName)
																			|| (GetInterface()->GetSelectMode() == C_szZdrName)))
    {
        CPA_SuperObject * pSuperObjectToSelect = GetZDxSuperObject (_pZDxToSelect , _pActorSuperObject);
        if (pSuperObjectToSelect)
        {
            GetInterface () -> fn_vCancelCurrentSelection (FALSE);
            GetInterface () -> fn_vAddSelectedObject (pSuperObjectToSelect , FALSE);
        }
    }

    m_bIsShowingOrHidingZDx = FALSE;
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - ShowAllZDxOfAllActors
// Insert all ZDx of all actors into the hierarchy
//-----------------------------------------------------------------------------
void ZDx_Interface::ShowAllZDxOfAllActors (unsigned char _ucZDxToShow , BOOL _bShowOnlySelected)
{
    IWillRefreshDisplay (C_lShowZDxOfAllActors);

    m_pActorSuperObjectToUnselect = NULL;

    CPA_List<CPA_SuperObject> * pListOfActorSuperObject = GetInterface () -> GetObjectListByType (C_szActorInstanceTypeName);

    POSITION Pos = pListOfActorSuperObject -> GetHeadPosition ();
    while (Pos)
    {
        CPA_SuperObject * pActorSuperObject = pListOfActorSuperObject -> GetNext (Pos);
        CPA_Actor       * pActor            = (CPA_Actor *) pActorSuperObject -> GetObject ();

        unsigned char ucZDxToShow = _ucZDxToShow;
        if (_bShowOnlySelected && pActor -> GetDisplayZone () == FALSE)  ucZDxToShow = C_ucHideAllZDx;

        // If _bShowOnlySelected, show only the zones that are selected, otherwise show all zones
        ShowZDxOfActor (pActorSuperObject , ucZDxToShow , NULL , _bShowOnlySelected ? (int) pActor -> GetDisplayZone () == 2 : FALSE);
    }

    RefreshDisplay (C_lShowZDxOfAllActors);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ShowZDxOfModule
// Show the ZDx of the modules of an instance (insert ZDx objects in the hierarchy)
//-----------------------------------------------------------------------------
void ZDx_Interface::ShowZDxOfModule (CPA_SuperObject * _pModuleSuperObject , unsigned char _ucZDxToShow ,
                                     ZDx_Object * _pZDxToSelect , BOOL _bSetEditProtected /* = FALSE */)
{
    if (m_pModuleSuperObjectToUnselect && m_pModuleSuperObjectToUnselect != _pModuleSuperObject)
    {
        ShowZDxOfModule (m_pModuleSuperObjectToUnselect , C_ucHideAllZDx , NULL);
        m_pModuleSuperObjectToUnselect = NULL;
    }

    m_bIsShowingOrHidingZDx = TRUE;

    EditorPO * pModule = (EditorPO *) _pModuleSuperObject -> GetObject ();
    if (! pModule)  return;

    BOOL bShowZdd = (_ucZDxToShow & C_ucShowZDD) != 0;
    BOOL bShowZde = (_ucZDxToShow & C_ucShowZDE) != 0;
    BOOL bShowZdm = (_ucZDxToShow & C_ucShowZDM) != 0;
    BOOL bShowZdr = (_ucZDxToShow & C_ucShowZDR) != 0;

    ZDx_Object * pZdd = (ZDx_Object *) pModule -> GetZone (C_ucTypeZdd);
    ZDx_Object * pZde = (ZDx_Object *) pModule -> GetZone (C_ucTypeZde);
    ZDx_Object * pZdm = (ZDx_Object *) pModule -> GetZone (C_ucTypeZdm); 
    ZDx_Object * pZdr = (ZDx_Object *) pModule -> GetZone (C_ucTypeZdr);
    if (pZdr && pZdr -> fn_bIsOfType (C_szZdrName) == FALSE)  pZdr = NULL;

    if (pZdd)  pZdd -> SetDisplay (eNotDisplayed);
    if (pZde)  pZde -> SetDisplay (eNotDisplayed);
    if (pZdm)  pZdm -> SetDisplay (eNotDisplayed);
    if (pZdr)  pZdr -> SetDisplay (eNotDisplayed);

    // We look for all ZDx child of the module :
    // For each ZDx, we set its Display flag, and we remove it from the hierarachy if it must not be shown
    CPA_SuperObject * pSuperObject = _pModuleSuperObject -> GetSuperObjectFirstChild ();
    CPA_SuperObject * pNextChild;
    while (pSuperObject)
    {
        pNextChild = _pModuleSuperObject -> GetSuperObjectNextChild (pSuperObject);

        // No object or not a ZDx -> go to the next child
        CPA_BaseObject * pObject = pSuperObject -> GetObject ();
        if (pObject == NULL || ! M_bIsThisObjectAZDx (pObject))
        {
            pSuperObject = pNextChild;
            continue;
        }
        ZDx_Object * pZDxObject = (ZDx_Object *) pObject;

        long lEngineType = pZDxObject -> GetDataType ();

        if ((lEngineType == C_lZDD && ! bShowZdd)    // if the ZDx must not be shown
         || (lEngineType == C_lZDE && ! bShowZde)
         || (lEngineType == C_lZDM && ! bShowZdm)
         || (lEngineType == C_lZDR && ! bShowZdr))
        {
            pZDxObject -> SetDisplay (eNotDisplayed);

            // Remove the object from the hierarchy
            GetInterface () -> fn_bDeleteObjectInHierarchy (pSuperObject , FALSE , FALSE);
        }
        else
        {
            pZDxObject -> SetDisplay (eDisplayed);
            SetAspectOfZDx (pSuperObject , pZDxObject == _pZDxToSelect);
            pSuperObject -> SetEditProtected (_bSetEditProtected);
        }

        pSuperObject = pNextChild;
    }

    if (bShowZdd)  CheckAndPutZDxIntoHierarchy (_pModuleSuperObject , pZdd , pZdd == _pZDxToSelect , _bSetEditProtected);
    if (bShowZde)  CheckAndPutZDxIntoHierarchy (_pModuleSuperObject , pZde , pZde == _pZDxToSelect , _bSetEditProtected);
    if (bShowZdm)  CheckAndPutZDxIntoHierarchy (_pModuleSuperObject , pZdm , pZdm == _pZDxToSelect , _bSetEditProtected);
    if (bShowZdr)  CheckAndPutZDxIntoHierarchy (_pModuleSuperObject , pZdr , pZdr == _pZDxToSelect , _bSetEditProtected);

    if (m_pList1Window -> IsEditingZDxOfModule ())
    {
        // If there is a ZDx object to select, we select it, else we select the Module
        // (if the user is not editing the zdx of module, we select nothing)
        CPA_SuperObject * pSuperObjectToSelect = _pZDxToSelect ? GetZDxSuperObject (_pZDxToSelect , _pModuleSuperObject) : _pModuleSuperObject;
        GetInterface () -> fn_vCancelCurrentSelection (FALSE);
        GetInterface () -> fn_vAddSelectedObject (pSuperObjectToSelect , FALSE);

        long DrawMask = GLI_C_lAllIsEnable ^ GLI_C_lIsNotDrawCollideInformation;
        if (_ucZDxToShow == C_ucHideAllZDx)                    // If we hide the zone of the module, one can select the module
        {
            _pModuleSuperObject -> SetEditProtected (FALSE);
        }                                                      // If we show the zone of the module
        else
        {
            _pModuleSuperObject -> SetEditProtected (TRUE);    // One cannot select the module
            DrawMask &= ~ GLI_C_lIsNotGrided;                  // and it is transparent
        }
        HIE_fn_vSetSuperObjectDrawMask (_pModuleSuperObject -> GetStruct () , DrawMask);
    }

    m_bIsShowingOrHidingZDx = FALSE;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ShowBoundingVolume
// Show the bounding volume of an actor
//-----------------------------------------------------------------------------
void ZDx_Interface::ShowBoundingVolume (CPA_SuperObject * _pActorSuperObject , ZDx_Object * _pBoundingVolume , BOOL _bSelectZDx)
{
    m_bIsShowingOrHidingZDx = TRUE;

    PutZDxIntoHierarchy (_pActorSuperObject , _pBoundingVolume , _bSelectZDx);

    m_bIsShowingOrHidingZDx = FALSE;
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - ShowModuleZDxRecursiv
// Show all zdx of a module and of all of its module childs
//-----------------------------------------------------------------------------
void ZDx_Interface::ShowModuleZDxRecursiv (CPA_SuperObject * _pModuleSuperObject)
{
    // The object
    CPA_BaseObject * pObject = _pModuleSuperObject -> GetObject ();
    if (pObject && pObject -> fn_bIsOfType (C_szPhysicalObjectTypeName))
        ShowZDxOfModule (_pModuleSuperObject , C_ucShowAllZDx , NULL , TRUE);

    // The childs
    CPA_SuperObject * pChildSuperObject = _pModuleSuperObject -> GetSuperObjectFirstChild ();
    while (pChildSuperObject)
    {
        ShowModuleZDxRecursiv (pChildSuperObject);
        pChildSuperObject = _pModuleSuperObject -> GetSuperObjectNextChild (pChildSuperObject);
    }
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - ShowModuleZDxOfActor
// Show all zdx of all modules of an actor
//-----------------------------------------------------------------------------
void ZDx_Interface::ShowModuleZDxOfActor (CPA_SuperObject * _pActorSuperObject)
{
    if (_pActorSuperObject)
	{
		IWillRefreshDisplay (C_lShowModuleZDxActor);

		// We look for all child of the actor :
		CPA_SuperObject * pSuperObject = _pActorSuperObject -> GetSuperObjectFirstChild ();
		while (pSuperObject)
		{
			ShowModuleZDxRecursiv (pSuperObject);
			pSuperObject = _pActorSuperObject -> GetSuperObjectNextChild (pSuperObject);
		}

		RefreshDisplay (C_lShowModuleZDxActor);
	}
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - HideModuleZDxRecursiv
// Hide all zdx of a module and of all of its module childs
//-----------------------------------------------------------------------------
void ZDx_Interface::HideModuleZDxRecursiv (CPA_SuperObject * _pModuleSuperObject)
{
    // The object
    CPA_BaseObject * pObject = _pModuleSuperObject -> GetObject ();
    if (pObject && pObject -> fn_bIsOfType (C_szPhysicalObjectTypeName))
        ShowZDxOfModule (_pModuleSuperObject , C_ucHideAllZDx);

    // The childs
    CPA_SuperObject * pChildSuperObject = _pModuleSuperObject -> GetSuperObjectFirstChild ();
    while (pChildSuperObject)
    {
        HideModuleZDxRecursiv (pChildSuperObject);
        pChildSuperObject = _pModuleSuperObject -> GetSuperObjectNextChild (pChildSuperObject);
    }
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - HideModuleZDxOfActor
// Hide all zdx of all modules of an actor
//-----------------------------------------------------------------------------
void ZDx_Interface::HideModuleZDxOfActor (CPA_SuperObject * _pActorSuperObject)
{
    if (_pActorSuperObject)
	{
		IWillRefreshDisplay (C_lHideModuleZDxActor);

		// We look for all child of the actor :
		CPA_SuperObject * pSuperObject = _pActorSuperObject -> GetSuperObjectFirstChild ();
		while (pSuperObject)
		{
			HideModuleZDxRecursiv (pSuperObject);
			pSuperObject = _pActorSuperObject -> GetSuperObjectNextChild (pSuperObject);
		}

		RefreshDisplay (C_lHideModuleZDxActor);
	}
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ShowZDxOfAllModule
// Show or hide the ZDx of all modules in the world
//-----------------------------------------------------------------------------
void ZDx_Interface::ShowZDxOfAllModule (unsigned char _ucZDxToShow)
{
    IWillRefreshDisplay (C_lShowZDxOfAllModule);

    CPA_List<CPA_SuperObject> * pListOfPhysicalSuperObject = GetInterface () -> GetObjectListByType	(C_szPhysicalObjectTypeName);

    POSITION Pos = pListOfPhysicalSuperObject -> GetHeadPosition ();
    while (Pos)
    {
        CPA_SuperObject * pSuperObject = pListOfPhysicalSuperObject -> GetNext (Pos);
        ShowZDxOfModule (pSuperObject , _ucZDxToShow);
    }

    RefreshDisplay (C_lShowZDxOfAllModule);
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - ShowZDxOfSelectedActor
// Show all zdx of selected actor
//-----------------------------------------------------------------------------
void ZDx_Interface::ShowZDxOfSelectedActor ()
{
    CPA_SuperObject * pSelectedActorSuperObject = GetSelectedActorSuperObject ();
    if (! pSelectedActorSuperObject)  return;

    IWillRefreshDisplay (C_lShowZDxSelectedActor);

    switch (m_pDisplayControlWindow -> GetDisplayForAllActors ())
    {
        case eNoZone     :
        case eOff      : m_pDisplayControlWindow -> SetDisplayForAllActors (eSelected);
                         SetDisplayFlagOfAllActors (FALSE);
                         break;
        case eOn       : break;
        case eSelected : break;
    }

    ((CPA_Actor *) pSelectedActorSuperObject -> GetObject ()) -> SetDisplayZone (TRUE);
    ShowZDxOfActor (pSelectedActorSuperObject , C_ucShowAllZDx);

    RefreshDisplay (C_lShowZDxSelectedActor);
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - HideZDxOfSelectedActor
// Hide all zdx of selected actor
//-----------------------------------------------------------------------------
void ZDx_Interface::HideZDxOfSelectedActor ()
{
    CPA_SuperObject * pSelectedActorSuperObject = GetSelectedActorSuperObject ();
    if (! pSelectedActorSuperObject)  return;

    IWillRefreshDisplay (C_lHideZDxSelectedActor);

    switch (m_pDisplayControlWindow -> GetDisplayForAllActors ())
    {
        case eNoZone     :
        case eOff      : break;
        case eOn       : m_pDisplayControlWindow -> SetDisplayForAllActors (eSelected);
                         SetDisplayFlagOfAllActors (TRUE);
                         break;
        case eSelected : break;
    }

    ((CPA_Actor *) pSelectedActorSuperObject -> GetObject ()) -> SetDisplayZone (FALSE);
    ShowZDxOfActor (pSelectedActorSuperObject , C_ucHideAllZDx);

    RefreshDisplay (C_lHideZDxSelectedActor);
}


//*****************************************************************************
//                              Refresh display
//*****************************************************************************


//-----------------------------------------------------------------------------
// Class ZDx_Interface - IWillRefreshDisplay
// Someone say he will refresh the display later (to prevent multiple refreshes)
// Return TRUE if nobody else has asked it before
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::IWillRefreshDisplay (long _lCallerID)
{
    if (! m_lRefreshDisplayCallerID)
    {
        m_lRefreshDisplayCallerID = _lCallerID;
        return TRUE;
    }
    else return FALSE;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - RefreshDisplay
// Refresh the display if the caller has asked it before (to prevent multiple refreshes)
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::RefreshDisplay (long _lCallerID , BOOL _bRefreshDisplay)
{
    if (m_lRefreshDisplayCallerID == _lCallerID)
    {
        if (_bRefreshDisplay)  GetInterface () -> fn_vUpdateAll (E_mc_JustDraw);

        m_lRefreshDisplayCallerID = 0;
        return TRUE;
    }
    else return FALSE;
}


//*****************************************************************************
//                         Check if ZDx are displayed
//*****************************************************************************


//-----------------------------------------------------------------------------
// class ZDx_Interface - AreZDxOfActorDisplayed
// Return if the ZDx of the actor are displayed or not
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::AreZDxOfActorDisplayed (CPA_SuperObject * _pActorSuperObject)
{
    // We look for all child of the actor :
    CPA_SuperObject * pSuperObject = _pActorSuperObject -> GetSuperObjectFirstChild ();
    while (pSuperObject)
    {
        CPA_BaseObject * pObject = pSuperObject -> GetObject ();
        if (pObject && M_bIsThisObjectAZDx (pObject))  return TRUE;  // One ZDx object found -> return TRUE

        pSuperObject = _pActorSuperObject -> GetSuperObjectNextChild (pSuperObject);
    }

    return FALSE;    // No ZDx object found -> return FALSE
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - AreZDxOfModuleDisplayed
// Return if the module has a ZDx object displayed or not
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::AreZDxOfModuleDisplayed (CPA_SuperObject * _pModuleSuperObject)
{
    // We look for all childs of the module
    CPA_SuperObject * pChildSuperObject = _pModuleSuperObject -> GetSuperObjectFirstChild ();
    while (pChildSuperObject)
    {
        CPA_BaseObject * pObject = pChildSuperObject -> GetObject ();
        if (pObject && M_bIsThisObjectAZDx (pObject))  return TRUE;  // One ZDx object found -> return TRUE;

        pChildSuperObject = _pModuleSuperObject -> GetSuperObjectNextChild (pChildSuperObject);
    }

    return FALSE;    // No ZDx object found -> return FALSE
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - AreZDxOfAllModuleDisplayed
// Return TRUE if at least one ZDx of one module in the world is displayed
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::AreZDxOfAllModuleDisplayed ()
{
    CPA_List<CPA_SuperObject> * pListOfPhysicalSuperObject = GetInterface () -> GetObjectListByType	(C_szPhysicalObjectTypeName);

    POSITION Pos = pListOfPhysicalSuperObject -> GetHeadPosition ();
    while (Pos)
    {
        CPA_SuperObject * pModuleSuperObject = pListOfPhysicalSuperObject -> GetNext (Pos);
        if (AreZDxOfModuleDisplayed (pModuleSuperObject))  return TRUE;
    }

    return FALSE;
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - AreZDxOfModuleDisplayedRecursiv
// Return if the ZDx of the given module and of all its module childs are displayed or not
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::AreZDxOfModuleDisplayedRecursiv (CPA_SuperObject * _pModuleSuperObject)
{
    CPA_SuperObject * pChildSuperObject = _pModuleSuperObject -> GetSuperObjectFirstChild ();
    while (pChildSuperObject)
    {
        CPA_BaseObject * pObject = pChildSuperObject -> GetObject ();
        if (pObject)
        {
            if (M_bIsThisObjectAZDx (pObject))  return TRUE;  // One ZDx object found -> return TRUE
            if (pObject -> fn_bIsOfType (C_szPhysicalObjectTypeName))
                if (AreZDxOfModuleDisplayedRecursiv (pChildSuperObject))  return TRUE;
        }

        pChildSuperObject = _pModuleSuperObject -> GetSuperObjectNextChild (pChildSuperObject);
    }

    return FALSE;
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - AreModuleZDxOfActorDisplayed
// Return if the module ZDx of the actor are displayed or not
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::AreModuleZDxOfActorDisplayed (CPA_SuperObject * _pActorSuperObject)
{
    // We look for all child of the actor :
    CPA_SuperObject * pSuperObject = _pActorSuperObject -> GetSuperObjectFirstChild ();
    while (pSuperObject)
    {
        CPA_BaseObject * pObject = pSuperObject -> GetObject ();
        if (pObject && pObject -> fn_bIsOfType (C_szPhysicalObjectTypeName))      // If it is a module
            if (AreZDxOfModuleDisplayedRecursiv (pSuperObject))  return TRUE;
        pSuperObject = _pActorSuperObject -> GetSuperObjectNextChild (pSuperObject);
    }

    return FALSE;    // No ZDx object found -> return FALSE
}


//*****************************************************************************
//                         Check if an actor has ZDx
//*****************************************************************************


//-----------------------------------------------------------------------------
// class ZDx_Interface - DoesActorHaveZDx
// Return if an actor has some ZDx or not
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::DoesActorHaveZDx (CPA_BaseObject * _pActor)
{
    return GetNumberOfZDxInList (GetZDxList (_pActor , eZdd)) > 0 ||
           GetNumberOfZDxInList (GetZDxList (_pActor , eZde)) > 0 ||
           GetNumberOfZDxInList (GetZDxList (_pActor , eZdm)) > 0 ||
           GetNumberOfZDxInList (GetZDxList (_pActor , eZdr)) > 0;
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - DoesActorHaveModuleZDx
// Return if an actor has some module ZDx or not
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::DoesActorHaveModuleZDx (CPA_SuperObject * _pActorSuperObject)
{
    // We look for all child of the actor :
    CPA_SuperObject * pSuperObject = _pActorSuperObject -> GetSuperObjectFirstChild ();
    while (pSuperObject)
    {
        CPA_BaseObject * pObject = pSuperObject -> GetObject ();
        if (pObject && pObject -> fn_bIsOfType (C_szPhysicalObjectTypeName))  // If it is a module
        {
            if (DoesModuleHaveZDxRecursiv (pSuperObject))  return TRUE;       // and if the module has some ZDx -> return TRUE
        }

        pSuperObject = _pActorSuperObject -> GetSuperObjectNextChild (pSuperObject);
    }

    return FALSE;    // No ZDx -> return FALSE;
}


//*****************************************************************************
//                                 List of zones
//*****************************************************************************


//-----------------------------------------------------------------------------
// class ZDx_Interface - GetNumberOfZDxInList
// Get the number of existing ZDx in a list
//-----------------------------------------------------------------------------
long ZDx_Interface::GetNumberOfZDxInList (EdtList * _pEdtList)
{
    if (! _pEdtList)  return 0;

    long lNumber = 0;

    POSITION Pos = _pEdtList -> GetHeadPosition ();
    while (Pos)
    {
        if (_pEdtList -> GetNext (Pos)) lNumber++;
    }

    return lNumber;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ConvertZDxTypeToListType
// Convert a ZDx type to a list type
//-----------------------------------------------------------------------------
CString ZDx_Interface::ConvertZDxTypeToListType (tdeZDxType _eZDxType)
{
    switch (_eZDxType)
    {
        case eZdd            : return C_szZddName;
        case eZde            : return C_szZdeName;
        case eZdm            : return C_szZdmName;
        case eZdr            : return C_szZdrName;
        case eBoundingVolume : return C_szBoundingVolumeName;
// ANNECY AV CLEAN_MEC {
//        case eTestPoint      : return C_szTestPointName;
// END ANNECY AV }
        default              : ASSERT (0);
                               return C_szZddName;
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ConvertListTypeToZDxType
// Convert a list type to a ZDx type
//-----------------------------------------------------------------------------
tdeZDxType ZDx_Interface::ConvertListTypeToZDxType (CString _szListType)
{
    if (_szListType == C_szZddName)             return eZdd;
    if (_szListType == C_szZdeName)             return eZde;
    if (_szListType == C_szZdmName)             return eZdm;
    if (_szListType == C_szZdrName)             return eZdr;
    if (_szListType == C_szBoundingVolumeName)  return eBoundingVolume;
// ANNECY AV CLEAN_MEC {
//    if (_szListType == C_szTestPointName)       return eTestPoint;
// END ANNECY AV }

    ASSERT (0);
    return eZdd;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - GetNameList
// Call the Actors dll to get the list of names of an actor for a specific type
//-----------------------------------------------------------------------------
CPA_tdoNameList * ZDx_Interface::GetNameList (CPA_BaseObject * _pActor , tdeZDxType _eZDxType)
{
    tdstEdtListMess  stEdtListMess;

    stEdtListMess . csListType      = ConvertZDxTypeToListType (_eZDxType);
    stEdtListMess . pActor          = _pActor;
    stEdtListMess . eConstraintType = eNormal;

    return (CPA_tdoNameList *) GetMainWorld () -> GetObjectDLLWithName (C_szDLLActorName) ->
                            OnQueryAction (this , C_uiActor_GetANameList , (long) & stEdtListMess);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - CreateANewZDxList
// Call the Actors dll to get a new list of objects of type zone
//-----------------------------------------------------------------------------
EdtList * ZDx_Interface::CreateANewZDxList (CPA_BaseObject * _pActor , tdeZDxType _eZDxType)
{
    tdstEdtListMess  stEdtListMess;

    stEdtListMess . csListType      = ConvertZDxTypeToListType (_eZDxType);
    stEdtListMess . pActor          = _pActor;
    stEdtListMess . eConstraintType = eNormal;

    return (EdtList *) GetMainWorld () -> GetObjectDLLWithName (C_szDLLActorName) -> 
                            OnQueryAction (this , C_uiActor_CreateANewObjectList , (long) & stEdtListMess);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - GetZDxList
// Call the Actors dll to get the list of given type of an actor
//-----------------------------------------------------------------------------
EdtList * ZDx_Interface::GetZDxList (CPA_BaseObject * _pActor , tdeZDxType _eZDxType)
{
    tdstEdtListMess  stEdtListMess;

    stEdtListMess . csListType      = ConvertZDxTypeToListType (_eZDxType);
    stEdtListMess . pActor          = _pActor;
    stEdtListMess . eConstraintType = eNormal;

    return (EdtList *) GetMainWorld () -> GetObjectDLLWithName (C_szDLLActorName) -> 
                            OnQueryAction (this , C_uiActor_GetAnObjectList , (long) & stEdtListMess);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - SetZDxList
// Call the Actors dll to set the list of given type of an actor
//-----------------------------------------------------------------------------
void ZDx_Interface::SetZDxList (CPA_BaseObject * _pActor , tdeZDxType _eZDxType , EdtList * _pZDxList)
{
    tdstEdtListMess  stEdtListMess;

    stEdtListMess . csListType      = ConvertZDxTypeToListType (_eZDxType);
    stEdtListMess . pActor          = _pActor;
    stEdtListMess . pList           = _pZDxList;
    stEdtListMess . eConstraintType = eNormal;
    
    GetMainWorld () -> GetObjectDLLWithName (C_szDLLActorName) -> 
            OnQueryAction (this , C_uiActor_SetAnObjectList , (long) & stEdtListMess);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - DeleteZDxList
// Call the Actors dll to delete a list of ZDx of an actor ; return FALSE if failure
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::DeleteZDxList (CPA_BaseObject * _pActor , tdeZDxType _eZDxType)
{
    tdstEdtListMess  stEdtListMess;

    stEdtListMess . csListType      = ConvertZDxTypeToListType (_eZDxType);
    stEdtListMess . pActor          = _pActor;
    stEdtListMess . eConstraintType = eNormal;

    // We make to delete notification for each ZDx object of the list
    EdtList * pEdtList = GetZDxList (_pActor , _eZDxType);
    POSITION  Pos      = pEdtList -> GetHeadPosition ();
    while (Pos)
    {
        ZDx_Object * pZDxObject = (ZDx_Object *) pEdtList -> GetNext (Pos);
        if (pZDxObject)  pZDxObject -> fn_vNotifyUnSave ();
    }

    BOOL bListDeleted = GetMainWorld () -> GetObjectDLLWithName (C_szDLLActorName) ->
                            OnQueryAction (this , C_uiActor_DeleteAnObjectList , (long) & stEdtListMess) == 0;

    // If the list has not been deleted, we undo the delete notification
    if (! bListDeleted)
    {
        POSITION Pos = pEdtList -> GetHeadPosition ();
        while (Pos)
        {
            ZDx_Object * pZDxObject = (ZDx_Object *) pEdtList -> GetNext (Pos);
            if (pZDxObject)  pZDxObject -> fn_vNotifyRestore ();
        }
    }

    return bListDeleted;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - SetZDxObjectInList
// Call the Actors dll to set a ZDx in a list of ZDx of an actor
//-----------------------------------------------------------------------------
void ZDx_Interface::SetZDxObjectInList (CPA_BaseObject * _pActor , tdeZDxType _eZDxType ,
                                        long _lIndexInList , ZDx_Object * _pZDxObject ,
                                        tdeZDxConstraintType _eZDxConstraintType)
{
    tdstEdtListMess  stEdtListMess;

    stEdtListMess . csListType      = ConvertZDxTypeToListType (_eZDxType);
    stEdtListMess . pActor          = _pActor;
    stEdtListMess . ulIndexInList   = _lIndexInList;
    stEdtListMess . pObject         = _pZDxObject;
    switch (_eZDxConstraintType)
    {
        case eZDxNormal          : stEdtListMess . eConstraintType = eNormal;           break;
        case eZDxModifyAllActors : stEdtListMess . eConstraintType = eModifyAllActors;  break;
        case eZDxModifyOneActor  : stEdtListMess . eConstraintType = eModifyOneActor;   break;
        default                  : ASSERT (0);                                          break;
    }

    if (_pZDxObject)  _pZDxObject -> SetIndexInList (_lIndexInList);

    GetMainWorld () -> GetObjectDLLWithName (C_szDLLActorName) -> 
            OnQueryAction (this , C_uiActor_SetAnObjectInObjectList , (long) & stEdtListMess);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - InsertZDxIntoList
// Insert a ZDx object into a list at a specific position (first position is 0)
// If Position = -1, insert it at the first unused position
// Failure -> return FALSE (no more unused position)
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::InsertZDxIntoList (EdtList * _pList , ZDx_Object * _pZDxObject , long * _plPosition ,
                                       CPA_BaseObject * _pActor , tdeZDxConstraintType _eZDxConstraintType)
{
    POSITION Pos;
    if (* _plPosition == -1)
    {
        // Search for an unused position
        Pos = _pList -> GetHeadPosition ();
        * _plPosition = 0;
        while (Pos && _pList -> GetAt (Pos))
        {
            (* _plPosition) ++;
            _pList -> GetNext (Pos);
        }
        // If there is no unused position, return FALSE
        if (! Pos)  return FALSE;
    }

    SetZDxObjectInList (_pActor , _pZDxObject -> GetZDxType () , * _plPosition ,_pZDxObject , _eZDxConstraintType);
    return TRUE;
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - RemoveZDxFromList
// Remove a ZDx object from a list
//-----------------------------------------------------------------------------
void ZDx_Interface::RemoveZDxFromList (EdtList * _pList , ZDx_Object * _pZDxObject , CPA_BaseObject * _pActor ,
                                       BOOL _bEnableListCreation /* = FALSE */)
{
    // Search the ZDx object in the list
    long     lPosition = 0;
    POSITION Pos       = _pList -> GetHeadPosition ();
    while (_pList -> GetAt (Pos) != _pZDxObject)
    {
        lPosition ++;
        _pList -> GetNext (Pos);
        // We must find the ZDx object before we reach the end of the list
        ASSERT (Pos);
    }

    // We save the position into the ZDx object
    _pZDxObject -> SetIndexInList (lPosition);

    // In fact, set a NULL ZDx object at the given position
    SetZDxObjectInList (_pActor , ConvertListTypeToZDxType (_pList -> fn_csGetListType ()) , lPosition , NULL ,
                        _bEnableListCreation ? eZDxNormal : eZDxModifyAllActors);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - AZDxHasBeenChangedInList
// Called when a ZDx has been changed in a list of ZDx
//-----------------------------------------------------------------------------
void ZDx_Interface::AZDxHasBeenChangedInList (void * _pEdtListMess)
{
    tdstEdtListMess * pEdtListMess = (tdstEdtListMess *) _pEdtListMess;
    // We get the actor
    CPA_BaseObject  * pActor       = pEdtListMess -> pActor;
    // We get the engine list
    ZDX_tdxHandleToZdxList hEngineList = (ZDX_tdxHandleToZdxList) pEdtListMess -> pList -> fn_hGetMotorList ();
    // Models don't have engine list, so hEngineList can be NULL. In this case, we do nothing
    if (! hEngineList)  return;
    // We get the type of the list
    tdeZDxType        eZDxType     = ConvertListTypeToZDxType   (pEdtListMess -> csListType);
    unsigned char     ucEngineType = ConvertZDxTypeToEngineType (eZDxType);
    // We get the index of the object in the list
    long              lIndexInList = pEdtListMess -> ulIndexInList;
    // We get the new ZDx object;
    POSITION          Position     = pEdtListMess -> pList -> FindIndex (lIndexInList);
    ZDx_Object      * pZDxObject   = (ZDx_Object *) pEdtListMess -> pList -> GetAt (Position);
    // We get the engine geometric object
    ACP_tdxHandleOfObject hGeometricEngineObject = pZDxObject ? pZDxObject -> GetZDxShape () ->
                                                   GetGeometric3dObject () -> GetStruct () : NULL;
    // We put the new ZDx object into the engine list
    ZDX_fn_vSetGeometricZdxInListAtIndex ((unsigned short) lIndexInList , hEngineList , hGeometricEngineObject);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - IsObjectInList
// Return TRUE if the given object is in a list of ZDx
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::IsObjectInList (CPA_BaseObject * _pObject, CPA_BaseObject * _pActor , tdeZDxType _eZDxType)
{
    EdtList * pEdtList = GetZDxList (_pActor , _eZDxType);
    if (! pEdtList)  return FALSE;

    POSITION Pos = pEdtList -> GetHeadPosition ();
    while (Pos)
    {
        CPA_BaseObject * pZDxObject = pEdtList -> GetNext (Pos);
        if (pZDxObject == _pObject)  return TRUE;
    }

    return FALSE;
}



//*****************************************************************************
//                              Physical objects
//*****************************************************************************


//-----------------------------------------------------------------------------
// Class ZDx_Interface - GetZDxOfPhysicalObject
// return the ZDx object of a given type of a physical object
//-----------------------------------------------------------------------------
ZDx_Object * ZDx_Interface::GetZDxOfPhysicalObject (EditorPO * _pPhysicalObject , tdeZDxType _eZDxType)
{
    switch (_eZDxType)
    {
        case eZdd : return (ZDx_Object *) _pPhysicalObject -> GetZone (C_ucTypeZdd);
        case eZde : return (ZDx_Object *) _pPhysicalObject -> GetZone (C_ucTypeZde);
        case eZdm : return (ZDx_Object *) _pPhysicalObject -> GetZone (C_ucTypeZdm);
        case eZdr : {
                        CPA_BaseObject * pZdr = _pPhysicalObject -> GetZone (C_ucTypeZdr);
                        return pZdr && pZdr -> fn_bIsOfType (C_szZdrName) ? (ZDx_Object *) pZdr : NULL;
                    }
        default   : ASSERT (0);
                    return NULL;
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - SetZDxOfPhysicalObject
// set the ZDx object (can be NULL) of a given type  for a physical object
//-----------------------------------------------------------------------------
void ZDx_Interface::SetZDxOfPhysicalObject (EditorPO * _pPhysicalObject , ZDx_Object * _pZDxObject , tdeZDxType _eZDxType)
{
    // If the ZDX_Object exists, it must has the same ZDx type
    ASSERT (_pZDxObject == NULL || _pZDxObject -> GetZDxType () == _eZDxType);

    switch (_eZDxType)
    {
        case eZdd : _pPhysicalObject -> SetZone (C_ucTypeZdd , _pZDxObject);    break;
        case eZde : _pPhysicalObject -> SetZone (C_ucTypeZde , _pZDxObject);    break;
        case eZdm : _pPhysicalObject -> SetZone (C_ucTypeZdm , _pZDxObject);    break;
        case eZdr : _pPhysicalObject -> SetZone (C_ucTypeZdr , _pZDxObject);    break;
        default   : ASSERT (0);                                  break;
    }
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - DoesModuleHaveZDx
// Return if a module has some ZDx or not
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::DoesModuleHaveZDx (EditorPO * _pModule)
{
    return GetZDxOfPhysicalObject (_pModule , eZdd) != NULL ||
           GetZDxOfPhysicalObject (_pModule , eZde) != NULL ||
           GetZDxOfPhysicalObject (_pModule , eZdm) != NULL ||
           GetZDxOfPhysicalObject (_pModule , eZdr) != NULL;
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - DoesModuleHaveZDxRecursiv
// Return if a module or one of its module childs has some ZDx or not
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::DoesModuleHaveZDxRecursiv (CPA_SuperObject * _pModuleSuperObject)
{
    // The module
    if (DoesModuleHaveZDx ((EditorPO *) _pModuleSuperObject -> GetObject ()))  return TRUE;

    // The childs
    CPA_SuperObject * pChildSuperObject = _pModuleSuperObject -> GetSuperObjectFirstChild ();
    while (pChildSuperObject)
    {
        CPA_BaseObject * pBaseObject = pChildSuperObject -> GetObject ();
        if (pBaseObject && pBaseObject -> fn_bIsOfType (C_szPhysicalObjectTypeName))
            if (DoesModuleHaveZDxRecursiv (pChildSuperObject))  return TRUE;

        pChildSuperObject = _pModuleSuperObject -> GetSuperObjectNextChild (pChildSuperObject);
    }

    return FALSE;
}

//-----------------------------------------------------------------------------
// class ZDx_Interface - DoesAtLeastOneModuleHaveZDx
// Return TRUE if at least one module in the world has some ZDx
//-----------------------------------------------------------------------------
BOOL ZDx_Interface::DoesAtLeastOneModuleHaveZDx ()
{
    CPA_List<CPA_SuperObject> * pListOfPhysicalSuperObject = GetInterface () -> GetObjectListByType	(C_szPhysicalObjectTypeName);

    POSITION Pos = pListOfPhysicalSuperObject -> GetHeadPosition ();
    while (Pos)
    {
        EditorPO * pModule = (EditorPO *) pListOfPhysicalSuperObject -> GetNext (Pos) -> GetObject ();
        if (DoesModuleHaveZDx (pModule))  return TRUE;
    }

    return FALSE;
}


//*****************************************************************************
//                     Personal functions for size changing
//*****************************************************************************

//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
/*
//-----------------------------------------------------------------------------
// Class ZDx_Interface - ChangeSizeZDxSphereObject
// Called by the function OnMouseMove when changing the size of a ZDx sphere object
//-----------------------------------------------------------------------------
void ZDx_Interface::ChangeSizeZDxSphereObject (MTH3D_tdstVector * pDeplacement)
{
    ZDx_Object * pZDxObject = (ZDx_Object *) m_stSizeChangingMode . pSelectedZDxSuperObject -> GetObject ();
    ZDx_Sphere * pSphere    = (ZDx_Sphere *) pZDxObject -> GetZDxShape ();

    MTH3D_M_vAddVector (& m_stSizeChangingMode . GlobalSelectedPoint , 
                        & m_stSizeChangingMode . GlobalSelectedPoint , pDeplacement);
    MTH3D_tdstVector RadiusVertex;
    MTH3D_M_vSubVector (& RadiusVertex , & m_stSizeChangingMode . GlobalSelectedPoint ,
                        & m_stSizeChangingMode . CenterInMousePlane);
    GLI_tdxValue NewRadius = MTH3D_M_xNormVector (& RadiusVertex); 
    pSphere -> SetRadius (& NewRadius);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ChangeSizeZDxBoxObject
// Called by the function OnMouseMove when changing the size of a ZDx box object
//-----------------------------------------------------------------------------
void ZDx_Interface::ChangeSizeZDxBoxObject (MTH3D_tdstVector * pDeplacement)
{
    CPA_SuperObject * pZDxSuperObject = m_stSizeChangingMode . pSelectedZDxSuperObject;
    ZDx_Object      * pZDxObject      = (ZDx_Object *) pZDxSuperObject -> GetObject ();
	ZDx_Box         * pBoxObject      = (ZDx_Box *) pZDxObject -> GetZDxShape ();

    MTH3D_tdstVector OldSize;
    MTH3D_M_vSetVectorElements (& OldSize , pBoxObject -> GetLength () ,
                                    pBoxObject -> GetWidth  () ,
                                    pBoxObject -> GetHeight ());

	// Calculate the deplacement in the local repere
    MTH3D_tdstVector LocalDeplacement;
    ConvertVectorGlobalToLocal (& LocalDeplacement , 
                                HIE_fn_hGetSuperObjectGlobalMatrix (pZDxSuperObject -> GetStruct ()) , 
                                pDeplacement);

    MTH3D_tdstVector Point = m_stSizeChangingMode . LocalSelectedPoint;

    // Set the new dimensions of the ZDx box object by moving one vertex
    if (Point . xX > 0)  pBoxObject -> IncMaxPointX (& LocalDeplacement . xX);
                    else pBoxObject -> IncMinPointX (& LocalDeplacement . xX);
    if (Point . xY > 0)  pBoxObject -> IncMaxPointY (& LocalDeplacement . xY);
                    else pBoxObject -> IncMinPointY (& LocalDeplacement . xY);
    if (Point . xZ > 0)  pBoxObject -> IncMaxPointZ (& LocalDeplacement . xZ);
                    else pBoxObject -> IncMinPointZ (& LocalDeplacement . xZ);

    // Calculate the real move and return it in pDeplacement
    MTH3D_tdstVector NewSize;
    MTH3D_M_vSetVectorElements (& NewSize , pBoxObject -> GetLength () ,
                                    pBoxObject -> GetWidth  () ,
                                    pBoxObject -> GetHeight ());
    MTH3D_tdstVector DeltaSize;
    MTH3D_M_vSubVector (& DeltaSize , & NewSize , & OldSize);
    if (Point . xX < 0)  DeltaSize . xX = - DeltaSize.xX;
    if (Point . xY < 0)  DeltaSize . xY = - DeltaSize.xY;
    if (Point . xZ < 0)  DeltaSize . xZ = - DeltaSize.xZ;

    ConvertVectorLocalToGlobal (pDeplacement , 
                                HIE_fn_hGetSuperObjectGlobalMatrix (pZDxSuperObject -> GetStruct ()) ,
                                & DeltaSize);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ChangeSizeZDxConeObject
// Called by the function OnMouseMove when changing the size of a ZDx cone object
//-----------------------------------------------------------------------------
void ZDx_Interface::ChangeSizeZDxConeObject (MTH3D_tdstVector * pDeplacement)
{
    CPA_SuperObject * pZDxSuperObject = m_stSizeChangingMode . pSelectedZDxSuperObject;
    ZDx_Object      * pZDxObject      = (ZDx_Object *) pZDxSuperObject -> GetObject ();
    ZDx_Cone        * pConeObject     = (ZDx_Cone *) pZDxObject -> GetZDxShape ();

    MTH3D_tdstVector LocalDeplacement;
    ConvertVectorGlobalToLocal (& LocalDeplacement ,
                                HIE_fn_hGetSuperObjectGlobalMatrix (pZDxSuperObject -> GetStruct ()) , 
                                pDeplacement);

    if (m_stSizeChangingMode . bChangeTopPointOfCone)    // We change the top point
    {
        MTH3D_tdstVector TopPoint = pConeObject -> GetTopPoint ();
        MTH3D_M_vAddVector (& TopPoint , & TopPoint , & LocalDeplacement);
        pConeObject -> SetTopPoint (& TopPoint);
    }
    else                          // We change the radius and the base point
    {
        MTH3D_tdstVector BasePoint = pConeObject -> GetBasePoint ();
        MTH3D_tdstVector TopPoint  = pConeObject -> GetTopPoint  ();
        // We splt the deplacement into radius change and base point change
        MTH3D_tdstVector BaseTopVector;
        MTH3D_M_vSubVector (& BaseTopVector , & TopPoint , & BasePoint);
        MTH_tdxReal      DotProduct = MTH3D_M_xDotProductVector (& BaseTopVector , & LocalDeplacement);
        MTH3D_tdstVector ProjectedVector;    // Projected into the axe
        MTH3D_M_vMulScalarVector (& ProjectedVector , DotProduct , & BaseTopVector);
        MTH3D_M_vDivScalarVector (& ProjectedVector , & ProjectedVector , MTH3D_M_xSqrVector (& BaseTopVector));

        // We change the base point
        MTH3D_M_vAddVector (& BasePoint , & BasePoint , & ProjectedVector);
        pConeObject -> SetBasePoint (& BasePoint);

        // We change the radius
        MTH3D_M_vAddVector (& m_stSizeChangingMode . LocalSelectedPoint ,
                            & m_stSizeChangingMode . LocalSelectedPoint , & LocalDeplacement);
        MTH3D_M_vSubVector (& m_stSizeChangingMode . LocalSelectedPoint ,
                            & m_stSizeChangingMode . LocalSelectedPoint , & ProjectedVector);
        MTH_tdxReal NewRadius = MTH3D_M_xVectorGap (& m_stSizeChangingMode .   LocalSelectedPoint , & BasePoint);
        pConeObject -> SetRadius (& NewRadius);
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - OnBeginChangingSize
// This function is called when the user begins to change the size of a ZDx object
//-----------------------------------------------------------------------------
void ZDx_Interface::OnBeginChangingSize (ACP_tdxIndex xIndex , HIE_tdstPickInfo * p_stObject)
{
    // we ask if there is a pointed zdd, zde, zdm, zdr or bounding volume
    CString TypeList [5] = { C_szZddName , C_szZdeName , C_szZdmName , C_szZdrName , C_szBoundingVolumeName};
    CPA_List<CPA_SuperObject> * pSelectedSuperObjectList = GetInterface () -> GetMouseSelection (xIndex , p_stObject , TypeList , 5);
    // if the list is empty, we do nothing
    if (pSelectedSuperObjectList -> IsEmpty ())  return;
    // else, we select the first super object in the list
    CPA_SuperObject * pSelectedSuperObject = pSelectedSuperObjectList -> GetHeadElement ();

    ZDx_Object * pZDxObject = (ZDx_Object *) pSelectedSuperObject -> GetObject ();

    // one can only change the size of a sphere, box or cone ZDx object
	tdeZDxGeometricType eZDxType = pZDxObject -> GetZDxGeometricType ();
	if (eZDxType != eSphere && eZDxType != eBox && eZDxType != eCone) return;

    // if the pointed ZDx object is not the actual selected ZDx object, we select it
    if (pZDxObject != m_pEditWindow -> GetZDxObjectEdited ())
    {
        GetInterface () -> fn_vCancelCurrentSelection (FALSE);
        GetInterface () -> fn_vAddSelectedObject (pSelectedSuperObject , TRUE);
    }


    // enter the "size changing" mode
    m_stSizeChangingMode . bActiveMode              = TRUE;
    m_stSizeChangingMode . pSelectedZDxSuperObject  = pSelectedSuperObject;
    m_stSizeChangingMode . GlobalSelectedPoint      = p_stObject->stPickedObject.aDEF_stDataOfElement->stHit;

    switch (pZDxObject -> GetZDxGeometricType ())
    {
    case eSphere:
        {
        // Get the center of the sphere
        ZDx_Sphere * pSphere = (ZDx_Sphere *) pZDxObject -> GetZDxShape ();
        MTH3D_tdstVector SphereCenter;
        // Compute coordinates in the global repere
        ConvertPointLocalToGlobal (& SphereCenter , 
                                   HIE_fn_hGetSuperObjectGlobalMatrix (m_stSizeChangingMode .
                                       pSelectedZDxSuperObject -> GetStruct ()) , & pSphere -> GetCenter ());

        // Get the matrix of the camera
        GLI_tdxHandleToCamera hHandleToCamera = GetInterface () -> GetMultiDevice () -> GetFocusDevice () -> GetCamera ();
        POS_tdstCompletePosition         CameraMatrix , InvMatrix;
        GLI_xGetCameraMatrix (hHandleToCamera , & CameraMatrix);
        POS_fn_vInvertIsoMatrix(& InvMatrix , & CameraMatrix);
        // Get the coordinates of the Z axe
        MTH3D_tdstVector        ZAxe , DummyVector;
        POS_fn_vGetRotationMatrix(& InvMatrix , & DummyVector , & DummyVector , & ZAxe);
        // Compute the sphere center, projected into the plane where the mouse moves into
        MTH3D_M_vSubVector       (& SphereCenter , & SphereCenter , & m_stSizeChangingMode . GlobalSelectedPoint);
        GLI_tdxValue DotProduct = MTH3D_M_xDotProductVector (& ZAxe , & SphereCenter);
        MTH3D_M_vMulScalarVector (& ZAxe , DotProduct , & ZAxe);
        MTH3D_M_vSubVector       (& SphereCenter , & SphereCenter , & ZAxe);
        MTH3D_M_vAddVector       (& m_stSizeChangingMode . CenterInMousePlane ,
                                  & SphereCenter , & m_stSizeChangingMode . GlobalSelectedPoint);
        }
        break;

    case eBox:
        {
        ZDx_Box * pBox = (ZDx_Box *) pZDxObject -> GetZDxShape ();

        ConvertPointGlobalToLocal (& m_stSizeChangingMode . LocalSelectedPoint , 
                                   HIE_fn_hGetSuperObjectGlobalMatrix (pSelectedSuperObject -> GetStruct ()) ,
                                   & m_stSizeChangingMode . GlobalSelectedPoint);
        MTH3D_M_vSubVector        (& m_stSizeChangingMode . LocalSelectedPoint , & m_stSizeChangingMode . LocalSelectedPoint ,
                                   & pBox -> GetCenter ());
        m_stSizeChangingMode . LocalSelectedPoint . xX /= pBox -> GetLength ();
        m_stSizeChangingMode . LocalSelectedPoint . xY /= pBox -> GetWidth  ();
        m_stSizeChangingMode . LocalSelectedPoint . xZ /= pBox -> GetHeight ();
        }
        break;

    case eCone:
        {
        ZDx_Cone * pCone = (ZDx_Cone *) pZDxObject -> GetZDxShape ();

        ConvertPointGlobalToLocal (& m_stSizeChangingMode . LocalSelectedPoint , 
                                   HIE_fn_hGetSuperObjectGlobalMatrix (pSelectedSuperObject -> GetStruct ()) ,
                                   & m_stSizeChangingMode . GlobalSelectedPoint);

        // We see if we must change the top point or the radius of the cone
        MTH3D_tdstVector TopPoint                    = pCone -> GetTopPoint  ();
        MTH3D_tdstVector BasePoint                   = pCone -> GetBasePoint ();
        MTH_tdxReal      SquareDistanceToTopPoint    = MTH3D_M_xVectorGapSqr (& m_stSizeChangingMode . LocalSelectedPoint , & TopPoint);
        MTH_tdxReal      SquareDistanceToBasePoint   = MTH3D_M_xVectorGapSqr (& m_stSizeChangingMode . LocalSelectedPoint , & BasePoint);
        if (SquareDistanceToTopPoint < SquareDistanceToBasePoint)
        {
            m_stSizeChangingMode . bChangeTopPointOfCone = TRUE;
        }
        else
        {
            m_stSizeChangingMode . bChangeTopPointOfCone = FALSE;

            // We project the picked point into the base plane
            MTH3D_tdstVector BaseTopVector;
            MTH3D_M_vSubVector (& BaseTopVector , & TopPoint , & BasePoint);
            MTH3D_tdstVector BasePointVector;
            MTH3D_M_vSubVector (& BasePointVector , & m_stSizeChangingMode . LocalSelectedPoint , & BasePoint);
            MTH_tdxReal      DotProduct = MTH3D_M_xDotProductVector (& BaseTopVector , & BasePointVector);
            MTH3D_tdstVector ProjectedVector;
            MTH3D_M_vMulScalarVector (& ProjectedVector , DotProduct , & BaseTopVector);
            MTH3D_M_vDivScalarVector (& ProjectedVector , & ProjectedVector , MTH3D_M_xSqrVector (& BaseTopVector));
            MTH3D_M_vAddVector (& m_stSizeChangingMode . LocalSelectedPoint ,
                                & m_stSizeChangingMode . LocalSelectedPoint , & ProjectedVector);
        }
        break;
        }

    default:
        ASSERT (0);
        break;
    }

    // we create a modif for the Undo
    m_stSizeChangingMode.pZDxModif = 
        new ZDx_Modif ((ZDx_Object *) m_stSizeChangingMode . pSelectedZDxSuperObject -> GetObject () , "Changing ZDx size");
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - OnEndChangingSize
// This function is called when the user has finished to change the size of a ZDx object
//-----------------------------------------------------------------------------
void ZDx_Interface::OnEndChangingSize ()
{
    // we leave the "size changing" mode
    m_stSizeChangingMode . bActiveMode = FALSE;

    // we must undo the modifications (without refreshing the window) ...
    m_stSizeChangingMode . pZDxModif -> Undo (FALSE);
    // ... because the edit manager redoes them
    GetInterface () -> GetMultiDevice () -> GetEditManager () -> AskFor (m_stSizeChangingMode . pZDxModif);
}
*/
//ENDROMTEAM WorldEditor (Cristi Petrescu)

//*****************************************************************************
//                      Compute dimension of objects
//*****************************************************************************

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ComputeBoundingBoxOfObject
// Compute the bounding box of a geometric object, and return its limits in _pMinPoint and _pMaxPoint
//-----------------------------------------------------------------------------
void ZDx_Interface::ComputeBoundingBoxOfObject (CPA_BaseObject * _pObject , POS_tdstCompletePosition  * _pGlobalMatrix , POS_tdstCompletePosition  * _pLocalMatrix , 
                                                MTH3D_tdstVector * _pMinPoint, MTH3D_tdstVector * _pMaxPoint)
{
    MTH3D_M_vSetVectorElements (_pMinPoint ,  1E6 ,  1E6 ,  1E6);
    MTH3D_M_vSetVectorElements (_pMaxPoint , -1E6 , -1E6 , -1E6);

    if (_pObject == NULL)  return;
    
    ACP_tdxHandleOfObject hObject;
    if (_pObject -> fn_bIsOfType (C_szGeometricObjectTypeName))
    {
        hObject = (ACP_tdxHandleOfObject) _pObject -> GetData ();
    }
    else
    if (_pObject -> fn_bIsOfType (C_szPhysicalObjectTypeName))
    {
        hObject = (ACP_tdxHandleOfObject) ((EditorPO *) _pObject) -> m_fnp_oGetGeometricWithDistance (0.0) -> GetData ();
    }
    else return;

    for (ACP_tdxIndex xNumPoint = 0 ; xNumPoint < GEO_xGetGeometricObjectNumberOfPoints (hObject) ; xNumPoint++)
    {
        MTH3D_tdstVector Point;
        GEO_vGetPointOfObject (hObject , & Point, xNumPoint);
        POS_fn_vMulMatrixVertex(& Point , _pLocalMatrix , & Point);
		POS_fn_vMulMatrixVector  (& Point , _pGlobalMatrix , & Point);

        MTH3D_M_vSetVectorElements (_pMinPoint ,
                                    MTH_M_xMin (MTH3D_M_xGetXofVector (_pMinPoint) , MTH3D_M_xGetXofVector (& Point)) ,
                                    MTH_M_xMin (MTH3D_M_xGetYofVector (_pMinPoint) , MTH3D_M_xGetYofVector (& Point)) ,
                                    MTH_M_xMin (MTH3D_M_xGetZofVector (_pMinPoint) , MTH3D_M_xGetZofVector (& Point)));

        MTH3D_M_vSetVectorElements (_pMaxPoint ,
                                    MTH_M_xMax (MTH3D_M_xGetXofVector (_pMaxPoint) , MTH3D_M_xGetXofVector (& Point)) ,
                                    MTH_M_xMax (MTH3D_M_xGetYofVector (_pMaxPoint) , MTH3D_M_xGetYofVector (& Point)) ,
                                    MTH_M_xMax (MTH3D_M_xGetZofVector (_pMaxPoint) , MTH3D_M_xGetZofVector (& Point)));
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ComputeBoundingBoxOfObjectAndChilds
// Compute the bounding box of an object and all of its childs, and return the limits in _pMinPoint and _pMaxPoint
//-----------------------------------------------------------------------------
void ZDx_Interface::ComputeBoundingBoxOfObjectAndChilds (CPA_SuperObject * _pSuperObject ,
                                                         MTH3D_tdstVector * _pMinPoint, MTH3D_tdstVector *_pMaxPoint)
{
    // The object
    CPA_BaseObject * pObject = _pSuperObject -> GetObject ();
    if (pObject)
    {
        POS_tdstCompletePosition  IdentityMatrix;
        POS_fn_vSetIdentityMatrix(& IdentityMatrix);

        ComputeBoundingBoxOfObject (pObject, & IdentityMatrix , &IdentityMatrix, _pMinPoint, _pMaxPoint);
    }

    // The childs
	POS_tdstCompletePosition  * pGlobalMatrix = HIE_fn_hGetSuperObjectGlobalMatrix (_pSuperObject -> GetStruct ());

    CPA_SuperObject * pChildSuperObject = _pSuperObject -> GetSuperObjectFirstChild ();
    while (pChildSuperObject)
    {
        MTH3D_tdstVector ChildMinPoint , ChildMaxPoint;

        POS_tdstCompletePosition  * pLocalMatrix = HIE_fn_hGetSuperObjectMatrix (pChildSuperObject -> GetStruct ());
		if(pChildSuperObject->GetObject())
		{
			ComputeBoundingBoxOfObject (pChildSuperObject -> GetObject () , pGlobalMatrix , pLocalMatrix, & ChildMinPoint , & ChildMaxPoint);
			MTH3D_M_vSetVectorElements (_pMinPoint,
                                    MTH_M_xMin (MTH3D_M_xGetXofVector (_pMinPoint) , MTH3D_M_xGetXofVector (& ChildMinPoint)) ,
                                    MTH_M_xMin (MTH3D_M_xGetYofVector (_pMinPoint) , MTH3D_M_xGetYofVector (& ChildMinPoint)) ,
                                    MTH_M_xMin (MTH3D_M_xGetZofVector (_pMinPoint) , MTH3D_M_xGetZofVector (& ChildMinPoint)));

			MTH3D_M_vSetVectorElements (_pMaxPoint,
                                    MTH_M_xMax (MTH3D_M_xGetXofVector (_pMaxPoint) , MTH3D_M_xGetXofVector (& ChildMaxPoint)) ,
                                    MTH_M_xMax (MTH3D_M_xGetYofVector (_pMaxPoint) , MTH3D_M_xGetYofVector (& ChildMaxPoint)) ,
                                    MTH_M_xMax (MTH3D_M_xGetZofVector (_pMaxPoint) , MTH3D_M_xGetZofVector (& ChildMaxPoint)));

		}
		else
		{
			CPA_SuperObject * pSPOChild = pChildSuperObject -> GetSuperObjectFirstChild(); 
			POS_tdstCompletePosition  * pSPOLocalMatrix = HIE_fn_hGetSuperObjectMatrix(pChildSuperObject -> GetStruct());

			while(pSPOChild)
			{
				MTH3D_tdstVector SPOChildMinPoint , SPOChildMaxPoint;
				POS_tdstCompletePosition    stSPOTransformMatrix;
				POS_tdstCompletePosition  * pSPOScaleMatrix = HIE_fn_hGetSuperObjectMatrix (pSPOChild -> GetStruct ());

				POS_fn_vSetIdentityMatrix(&stSPOTransformMatrix);
				POS_fn_vMulMatrixMatrix(&stSPOTransformMatrix, pSPOLocalMatrix, pSPOScaleMatrix);

				ComputeBoundingBoxOfObject (pSPOChild -> GetObject () , pGlobalMatrix , &stSPOTransformMatrix, & SPOChildMinPoint , & SPOChildMaxPoint);

				MTH3D_M_vSetVectorElements (_pMinPoint,
                                    MTH_M_xMin (MTH3D_M_xGetXofVector (_pMinPoint) , MTH3D_M_xGetXofVector (& SPOChildMinPoint)) ,
                                    MTH_M_xMin (MTH3D_M_xGetYofVector (_pMinPoint) , MTH3D_M_xGetYofVector (& SPOChildMinPoint)) ,
                                    MTH_M_xMin (MTH3D_M_xGetZofVector (_pMinPoint) , MTH3D_M_xGetZofVector (& SPOChildMinPoint)));

		        MTH3D_M_vSetVectorElements (_pMaxPoint,
                                    MTH_M_xMax (MTH3D_M_xGetXofVector (_pMaxPoint) , MTH3D_M_xGetXofVector (& SPOChildMaxPoint)) ,
                                    MTH_M_xMax (MTH3D_M_xGetYofVector (_pMaxPoint) , MTH3D_M_xGetYofVector (& SPOChildMaxPoint)) ,
                                    MTH_M_xMax (MTH3D_M_xGetZofVector (_pMaxPoint) , MTH3D_M_xGetZofVector (& SPOChildMaxPoint)));
		
				pSPOChild = pChildSuperObject -> GetSuperObjectNextChild (pSPOChild);
			}
		}
		pChildSuperObject = _pSuperObject -> GetSuperObjectNextChild (pChildSuperObject);
    }
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ComputeInitialSizeOfBox
// Compute the bounding box dimension of an object and all of its childs
//-----------------------------------------------------------------------------
void ZDx_Interface::ComputeInitialSizeOfBox (CPA_SuperObject * _pSuperObject ,
                                             MTH3D_tdstVector * MinPoint , MTH3D_tdstVector * MaxPoint)
{
    ComputeBoundingBoxOfObjectAndChilds (_pSuperObject , MinPoint , MaxPoint);
}

//-----------------------------------------------------------------------------
// Class ZDx_Interface - ComputeInitialSizeOfSphere
// Compute the bounding sphere radius of an object and all of its childs
//-----------------------------------------------------------------------------
MTH_tdxReal ZDx_Interface::ComputeInitialSizeOfSphere (CPA_SuperObject * _pSuperObject , MTH3D_tdstVector * Center)
{
    // Compute min and max points
    MTH3D_tdstVector	MinPoint , MaxPoint;


    ComputeBoundingBoxOfObjectAndChilds (_pSuperObject , & MinPoint , & MaxPoint);

	/* Now the function ComputeBoundingBoxOfObjectAndChilds returns a Min and a Max point
		that are computed in the global axis system WITHOUT the translation of the object */
	/* There could be some bug if the Z axis was not the same for a character and for the world */

    // Compute the center
    MTH3D_M_vMiddleVector (Center , & MinPoint , & MaxPoint);

    // Compute and return the radius
    MTH3D_tdstVector Difference;
    MTH3D_M_vSubVector       (& Difference , & MaxPoint , & MinPoint);
    MTH3D_M_vMulScalarVector (& Difference , (float) 0.5 , & Difference);

    return MTH_M_xMax (MTH_M_xMax (MTH3D_M_xGetXofVector (& Difference) , MTH3D_M_xGetYofVector (& Difference)) ,
                       MTH3D_M_xGetZofVector (& Difference));
}
