Home

nevrax.com

Nevrax.org News Mailing-list Documentation CVS Bugs License

Documentation                       Search   instance_group_user.cpp Go to the documentation of this file. /* Copyright, 2001 Nevrax Ltd. * * This file is part of NEVRAX NEL. * NEVRAX NEL is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * NEVRAX NEL is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * You should have received a copy of the GNU General Public License * along with NEVRAX NEL; see the file COPYING. If not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, * MA 02111-1307, USA. */ #include "std3d.h" #include "3d/instance_user.h" #include "nel/misc/debug.h" #include "3d/instance_group_user.h" #include "3d/scene_user.h" #include "3d/mesh_multi_lod_instance.h" #include "nel/misc/path.h" #include "nel/misc/file.h" using namespace NLMISC; using namespace std; namespace NL3D { // *************************************************************************** UInstanceGroup *UInstanceGroup::createInstanceGroup (const std::string &instanceGroup) { NL3D_MEM_IG // Create the instance group CInstanceGroupUser *user=new CInstanceGroupUser; // Init the class if (!user->init (instanceGroup)) { // Prb, erase it delete user; // Return error code return NULL; } // return the good value return user; } // *************************************************************************** void UInstanceGroup::createInstanceGroupAsync (const std::string &instanceGroup, UInstanceGroup **pIG) { NL3D_MEM_IG CAsyncFileManager3D::getInstance().loadIGUser (instanceGroup, pIG); } // *************************************************************************** void UInstanceGroup::stopCreateInstanceGroupAsync (UInstanceGroup **ppIG) { NL3D_MEM_IG // Theorically should stop the async file manager but the async file manager can only be stopped // between tasks (a file reading) so that is no sense to do anything here while (*ppIG == NULL) { nlSleep (2); } if (*ppIG != (UInstanceGroup*)-1) { delete *ppIG; } } // *************************************************************************** CInstanceGroupUser::CInstanceGroupUser() { NL3D_MEM_IG _AddToSceneState = StateNotAdded; } // *************************************************************************** bool CInstanceGroupUser::init (const std::string &instanceGroup) { NL3D_MEM_IG // Create a file CIFile file; std::string path = CPath::lookup (instanceGroup, false); if (!path.empty() && file.open (path)) { // Serialize this class try { // Read the class _InstanceGroup.serial (file); } catch (EStream& e) { // Avoid visual warning EStream ee=e; // Serial problem return false; } } else { // Failed. return false; } // Ok return true; } // *************************************************************************** void CInstanceGroupUser::setTransformNameCallback (ITransformName *pTN) { NL3D_MEM_IG _InstanceGroup.setTransformNameCallback (pTN); } // *************************************************************************** void CInstanceGroupUser::setAddRemoveInstanceCallback(IAddRemoveInstance *callback) { NL3D_MEM_IG _InstanceGroup.setAddRemoveInstanceCallback(callback); } // *************************************************************************** void CInstanceGroupUser::setIGAddBeginCallback(IIGAddBegin *callback) { NL3D_MEM_IG _InstanceGroup.setIGAddBeginCallback(callback); } // *************************************************************************** void CInstanceGroupUser::addToScene (class UScene& scene, UDriver *driver) { NL3D_MEM_IG // Get driver pointer IDriver *cDriver= driver ? NLMISC::safe_cast<CDriverUser*>(driver)->getDriver() : NULL; // Add to the scene addToScene (((CSceneUser*)&scene)->getScene(), cDriver); } // *************************************************************************** void CInstanceGroupUser::getInstanceMatrix(uint instanceNb,NLMISC::CMatrix &dest) const { NL3D_MEM_IG _InstanceGroup.getInstanceMatrix(instanceNb, dest); } // *************************************************************************** void CInstanceGroupUser::addToScene (class CScene& scene, IDriver *driver) { NL3D_MEM_IG _InstanceGroup.addToScene (scene, driver); // Fill in the map accelerating search of instance by names for( uint32 i = 0; i < _InstanceGroup._Instances.size(); ++i) { CInstanceUser *pIU = NULL; string stmp; if (_InstanceGroup._Instances[i] != NULL) { pIU = new CInstanceUser (&scene, _InstanceGroup._Instances[i]); stmp = _InstanceGroup.getInstanceName (i); _Instances.insert (map<string,CInstanceUser*>::value_type(stmp, pIU)); } } } // *************************************************************************** void CInstanceGroupUser::addToSceneAsync (class UScene& scene, UDriver *driver) { NL3D_MEM_IG IDriver *cDriver= driver ? NLMISC::safe_cast<CDriverUser*>(driver)->getDriver() : NULL; // Add to the scene _InstanceGroup.addToSceneAsync (((CSceneUser*)&scene)->getScene(), cDriver); _AddToSceneState = StateAdding; _AddToSceneTempScene = &scene; _AddToSceneTempDriver = driver; } // *************************************************************************** void CInstanceGroupUser::stopAddToSceneAsync () { NL3D_MEM_IG _InstanceGroup.stopAddToSceneAsync (); } // *************************************************************************** UInstanceGroup::TState CInstanceGroupUser::getAddToSceneState () { NL3D_MEM_IG UInstanceGroup::TState newState = (UInstanceGroup::TState)_InstanceGroup.getAddToSceneState (); if ((_AddToSceneState == StateAdding) && (newState == StateAdded)) { // Fill in the map accelerating search of instance by names for( uint32 i = 0; i < _InstanceGroup._Instances.size(); ++i) { CInstanceUser *pIU = NULL; string stmp; if (_InstanceGroup._Instances[i] != NULL) { pIU = new CInstanceUser (&((CSceneUser*)_AddToSceneTempScene)->getScene(), _InstanceGroup._Instances[i]); stmp = _InstanceGroup.getInstanceName (i); _Instances.insert (map<string,CInstanceUser*>::value_type(stmp, pIU)); } } _AddToSceneState = StateAdded; } return newState; } // *************************************************************************** void CInstanceGroupUser::removeFromScene (class UScene& scene) { NL3D_MEM_IG _InstanceGroup.removeFromScene (((CSceneUser*)&scene)->getScene()); // Remove all instance in the map map<string,CInstanceUser*>::iterator it = _Instances.begin(); while (it != _Instances.end()) { map<string,CInstanceUser*>::iterator itDel = it; ++it; _Instances.erase (itDel); } } // *************************************************************************** uint CInstanceGroupUser::getNumInstance () const { NL3D_MEM_IG return _InstanceGroup.getNumInstance (); } // *************************************************************************** const std::string& CInstanceGroupUser::getShapeName (uint instanceNb) const { NL3D_MEM_IG // Check args if (instanceNb>=_InstanceGroup.getNumInstance ()) nlerror("getShapeName*(): bad instance Id"); return _InstanceGroup.getShapeName (instanceNb); } // *************************************************************************** const std::string& CInstanceGroupUser::getInstanceName (uint instanceNb) const { NL3D_MEM_IG // Check args if (instanceNb>=_InstanceGroup.getNumInstance ()) nlerror("getInstanceName*(): bad instance Id"); return _InstanceGroup.getInstanceName (instanceNb); } // *************************************************************************** const NLMISC::CVector& CInstanceGroupUser::getInstancePos (uint instanceNb) const { NL3D_MEM_IG // Check args if (instanceNb>=_InstanceGroup.getNumInstance ()) nlerror("getInstancePos*(): bad instance Id"); return _InstanceGroup.getInstancePos (instanceNb); } // *************************************************************************** const NLMISC::CQuat& CInstanceGroupUser::getInstanceRot (uint instanceNb) const { NL3D_MEM_IG // Check args if (instanceNb>=_InstanceGroup.getNumInstance ()) nlerror("getInstanceRot*(): bad instance Id"); return _InstanceGroup.getInstanceRot (instanceNb); } // *************************************************************************** const NLMISC::CVector& CInstanceGroupUser::getInstanceScale (uint instanceNb) const { NL3D_MEM_IG // Check args if (instanceNb>=_InstanceGroup.getNumInstance ()) nlerror("getInstanceScale*(): bad instance Id"); return _InstanceGroup.getInstanceScale (instanceNb); } // *************************************************************************** UInstance *CInstanceGroupUser::getByName (std::string &name) { NL3D_MEM_IG map<string,CInstanceUser*>::iterator it = _Instances.find (name); if (it != _Instances.end()) return it->second; else return NULL; } // *************************************************************************** const UInstance *CInstanceGroupUser::getByName (std::string &name) const { NL3D_MEM_IG map<string,CInstanceUser*>::const_iterator it = _Instances.find (name); if (it != _Instances.end()) return it->second; else return NULL; } // *************************************************************************** void CInstanceGroupUser::setLightFactor (const std::string &LightName, CRGBA nFactor) { NL3D_MEM_IG _InstanceGroup.setLightFactor (LightName, nFactor); } // *************************************************************************** void CInstanceGroupUser::setBlendShapeFactor (const std::string &bsName, float rFactor) { NL3D_MEM_IG _InstanceGroup.setBlendShapeFactor (bsName, rFactor); } // *************************************************************************** void CInstanceGroupUser::createRoot (UScene &scene) { NL3D_MEM_IG _InstanceGroup.createRoot (((CSceneUser*)&scene)->getScene()); } // *************************************************************************** void CInstanceGroupUser::setClusterSystem (UInstanceGroup *pClusterSystem) { NL3D_MEM_IG _InstanceGroup.setClusterSystem (&((CInstanceGroupUser*)pClusterSystem)->_InstanceGroup); } // *************************************************************************** bool CInstanceGroupUser::linkToParentCluster(UInstanceGroup *father) { NL3D_MEM_IG if (father) return _InstanceGroup.linkToParent(&(NLMISC::safe_cast<CInstanceGroupUser *>(father)->_InstanceGroup)); else { nlwarning("Trying to link a cluster system to a NULL parent cluster"); return false; } } // *************************************************************************** void CInstanceGroupUser::getDynamicPortals (std::vector<std::string> &names) { NL3D_MEM_IG _InstanceGroup.getDynamicPortals (names); } // *************************************************************************** void CInstanceGroupUser::setDynamicPortal (std::string& name, bool opened) { NL3D_MEM_IG _InstanceGroup.setDynamicPortal (name, opened); } // *************************************************************************** bool CInstanceGroupUser::getDynamicPortal (std::string& name) { NL3D_MEM_IG return _InstanceGroup.getDynamicPortal (name); } // *************************************************************************** void CInstanceGroupUser::setPos (const NLMISC::CVector &pos) { NL3D_MEM_IG _InstanceGroup.setPos (pos); } // *************************************************************************** void CInstanceGroupUser::setRotQuat (const NLMISC::CQuat &q) { NL3D_MEM_IG _InstanceGroup.setRotQuat (q); } // *************************************************************************** CVector CInstanceGroupUser::getPos () { NL3D_MEM_IG return _InstanceGroup.getPos (); } // *************************************************************************** CQuat CInstanceGroupUser::getRotQuat () { NL3D_MEM_IG return _InstanceGroup.getRotQuat(); } // *************************************************************************** void CInstanceGroupUser::freezeHRC() { NL3D_MEM_IG _InstanceGroup.freezeHRC(); } // *************************************************************************** void CInstanceGroupUser::unfreezeHRC() { NL3D_MEM_IG _InstanceGroup.unfreezeHRC(); } // *************************************************************************** void CInstanceGroupUser::setPointLightFactor(const std::string &lightGroupName, NLMISC::CRGBA nFactor) { NL3D_MEM_IG _InstanceGroup.setPointLightFactor(lightGroupName, nFactor); } // *************************************************************************** bool CInstanceGroupUser::getStaticLightSetup( const std::string &retrieverIdentifier, sint surfaceId, const NLMISC::CVector &localPos, std::vector<CPointLightInfluence> &pointLightList, uint8 &sunContribution, NLMISC::CRGBA &localAmbient) { NL3D_MEM_IG return _InstanceGroup.getStaticLightSetup(retrieverIdentifier, surfaceId, localPos, pointLightList, sunContribution, localAmbient); } // *************************************************************************** /*virtual*/ void CInstanceGroupUser::setDistMax(uint instance, float dist) { if (instance > _InstanceGroup.getNumInstance()) { nlwarning("CInstanceGroupUser::setDistMax : instance index %d is invalid", instance); return; } if (_InstanceGroup._Instances[instance]) _InstanceGroup._Instances[instance]->setDistMax(dist); } // *************************************************************************** /*virtual*/ float CInstanceGroupUser::getDistMax(uint instance) const { if (instance > _InstanceGroup.getNumInstance()) { nlwarning("CInstanceGroupUser::getDistMax : instance index %d is invalid", instance); return -1.f; } if (_InstanceGroup._Instances[instance]) return _InstanceGroup._Instances[instance]->getDistMax(); else return -1.f; } // *************************************************************************** /*virtual*/ void CInstanceGroupUser::setCoarseMeshDist(uint instance, float dist) { if (instance > _InstanceGroup.getNumInstance()) { nlwarning("CInstanceGroupUser::setCoarseMeshDist : instance index %d is invalid", instance); return; } if (_InstanceGroup._Instances[instance]) { CMeshMultiLodInstance *mmli = dynamic_cast<CMeshMultiLodInstance *>(_InstanceGroup._Instances[instance]); if (mmli) mmli->setCoarseMeshDist(dist); } } // *************************************************************************** /*virtual*/ float CInstanceGroupUser::getCoarseMeshDist(uint instance) const { if (instance > _InstanceGroup.getNumInstance()) { nlwarning("getCoarseMeshDist::getDistMax : instance index %d is invalid", instance); return -1.f; } if (_InstanceGroup._Instances[instance]) { CMeshMultiLodInstance *mmli = dynamic_cast<CMeshMultiLodInstance *>(_InstanceGroup._Instances[instance]); if (mmli) return mmli->getCoarseMeshDist(); else return -1.f; } else return -1.f; } } // NL3D