bool CPhysxSkeleton::AddFixedJoint(CXMLTreeNode _XMLObjects) { string l_szActor1,l_szActor2, l_szDirection; l_szActor1 = _XMLObjects.GetPszISOProperty("Actor1" ,""); l_szActor2 = _XMLObjects.GetPszISOProperty("Actor2" ,""); l_szDirection = _XMLObjects.GetPszISOProperty("Direction" ,""); CPhysxBone* l_pBone1 = GetPhysxBoneByName(l_szActor1); CPhysxBone* l_pBone2 = GetPhysxBoneByName(l_szActor2); CPhysicActor* l_pActor1 = 0; CPhysicActor* l_pActor2 = 0; CPhysicFixedJoint* l_pFixedJoint = 0; l_pFixedJoint = new CPhysicFixedJoint(); l_pActor1 = l_pBone1->GetPhysxActor(); if (l_szActor2=="NULL") { l_pFixedJoint->SetInfo(l_pActor1); } else { l_pActor2 = l_pBone2->GetPhysxActor(); l_pFixedJoint->SetInfo(l_pActor1,l_pActor2); } CORE->GetPhysicsManager()->AddPhysicFixedJoint(l_pFixedJoint); m_vFixedJoints.push_back(l_pFixedJoint); return true; }
//---------------------------------------------------------------------------- // Checks if a key is on the tree //---------------------------------------------------------------------------- bool CXMLTreeNode::ExistsKey (const char* _pszKey) { assert(_pszKey); CXMLTreeNode TreeFound = GetSubTree(_pszKey); return TreeFound.Exists(); }
CDrawQuadRendererCommand::CDrawQuadRendererCommand(CXMLTreeNode &atts) : CStagedTexturedRendererCommand(atts) { int l_count_textures = atts.GetNumChildren(); for (int i=0; i<l_count_textures; ++i) { int l_StageId = atts(i).GetIntProperty("stage_id", 0); std::string l_File = atts(i).GetPszProperty("file",""); CTexture* l_Texture = CORE->GetTextureManager()->GetTexture(l_File); if (l_Texture != NULL) { CStagedTexturedRendererCommand::AddStageTexture(l_StageId, l_Texture); } } bool l_TextureWidhtAsFrameBuffer = atts.GetBoolProperty("texture_width_as_frame_buffer", true); uint32 w,h; if (l_TextureWidhtAsFrameBuffer) { CORE->GetRenderManager()->GetWidthAndHeight(w, h); } else { w = atts.GetIntProperty("width", 0); h = atts.GetIntProperty("height", 0); } m_Rect.top=m_Rect.left=(long)0.0; m_Rect.right=w-1; m_Rect.bottom=h-1; }
void CAnimatedMeshManager::Load(const std::string &Filename) { CXMLTreeNode l_XML; if (l_XML.LoadFile(Filename.c_str())) { CXMLTreeNode animatedModels = l_XML["animated_models"]; if (animatedModels.Exists()) { for (int i = 0; i < animatedModels.GetNumChildren(); ++i) { CXMLTreeNode animated_model = animatedModels(i); if (animated_model.GetName() == std::string("animated_model")) { CXMLTreeNode &animModel = animated_model; auto inst = new CAnimatedMesh(animModel); add(inst->getName(), inst); } } } } }
bool CRenderableObjectTechniqueManager::LoadFile() { CXMLTreeNode newFile; if (!newFile.LoadFile(m_FileName.c_str())) { std::string msg_error = "CRenderableObjectTechniqueManager::Load->Error al intentar leer el archivo de renderable objects techniques: " + m_FileName; LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str()); return false; } CXMLTreeNode l_ROTs = newFile["renderable_object_techniques"]; if( l_ROTs.Exists() ) { uint16 l_Count = l_ROTs.GetNumChildren(); for( uint16 i=0; i < l_Count; ++i) { std::string l_Type = l_ROTs(i).GetName(); if( l_Type == "pool_renderable_object_technique" ) { std::string l_PROTName = l_ROTs(i).GetPszProperty("name", ""); CPoolRenderableObjectTechnique *l_PoolROT = new CPoolRenderableObjectTechnique(l_ROTs(i)); l_PoolROT->SetName(l_PROTName); m_PoolRenderableObjectTechniques.AddResource(l_PROTName, l_PoolROT); uint16 l_Child = l_ROTs(i).GetNumChildren(); for(uint16 j=0; j < l_Child; ++j) { l_Type = l_ROTs(i)(j).GetName(); if( l_Type == "default_technique" ) { int l_VertexType = l_ROTs(i)(j).GetIntProperty("vertex_type", 0); std::string l_Technique = l_ROTs(i)(j).GetPszProperty("technique", ""); std::string l_Name = GetRenderableObjectTechniqueNameByVertexType( static_cast<uint32>(l_VertexType) ); InsertRenderableObjectTechnique(l_Name, l_Technique); l_PoolROT->AddElement(l_Name, l_Technique, GetResource(l_Name) ); } else if( l_Type == "technique" ) { std::string l_Name = l_ROTs(i)(j).GetPszProperty("name", ""); std::string l_Technique = l_ROTs(i)(j).GetPszProperty("technique", ""); InsertRenderableObjectTechnique(l_Name, l_Technique); l_PoolROT->AddElement(l_Name, l_Technique, GetResource(l_Name) ); } } } } } else { return false; } return true; }
bool CTriggerManager::LoadXML( const std::string& FileName ) { mConfigPath = FileName; CXMLTreeNode newFile; if ( !newFile.LoadFile( FileName.c_str() ) ) { LOG_ERROR_APPLICATION( "CTriggerManager::LoadXML=> ERROR loading the file %s.\n", FileName.c_str() ); return false; } CXMLTreeNode m = newFile["triggers"]; if ( m.Exists() ) { int count = m.GetNumChildren(); for ( int i = 0; i < count; ++i ) { const std::string l_TagName = m( i ).GetName(); if ( l_TagName == "trigger" ) { CTrigger* l_Trigger = new CTrigger( m( i ) ); if(!AddResource(l_Trigger->GetName(), l_Trigger)) { CHECKED_DELETE(l_Trigger); } } } } return true; }
CElevatorAnimatedPhysicModel::CElevatorAnimatedPhysicModel(const CXMLTreeNode& XmlData, CAnimatedCoreModel* coreModel) : CAnimatedInstanceModel(XmlData) { Initialize(coreModel); std::string l_Name = XmlData.GetPszProperty("name",""); std::string l_Core = XmlData.GetPszProperty("core",""); std::string l_Type = XmlData.GetPszProperty("physics_type",""); CStaticMesh* l_StaticMesh = CORE->GetStaticMeshManager()->GetResource(l_Name); if (l_StaticMesh!=NULL) { m_PhysicElement= new CPhysicElement(l_Core,l_Type); m_PhysicElement->m_UserData->SetPaint(true); m_PhysicElement->m_UserData->SetColor(colBLUE); if (l_Type=="triangle_mesh") { m_PhysicElement->m_PhysicActor->CreateBody(100.0f); CORE->GetPhysicsManager()->GetCookingMesh()->CreatePhysicMesh(l_StaticMesh->getVB(),l_StaticMesh->getIB(),l_Name); NxTriangleMesh* l_TriangleMesh= CORE->GetPhysicsManager()->GetCookingMesh()->GetPhysicMesh(l_Name); m_PhysicElement->m_PhysicActor->AddMeshShape(l_TriangleMesh,m_Position); CORE->GetPhysicsManager()->AddPhysicActor(m_PhysicElement->m_PhysicActor); m_PhysicElement->m_PhysicActor->SetKinematic(true); } } }
void CEnemyInstance::InitInstance(CXMLTreeNode& _XMLParams) { m_vPosition = _XMLParams.GetVect3fProperty("pos",Vect3f(0.0f)); m_vRotate = _XMLParams.GetVect3fProperty("rot",Vect3f(0.0f)); SetOk(true); }
/// <summary> /// Carga el .xml de triggers. /// </summary> ///<param name="FileName">Ubicación del archivo xml.</param> bool CTriggerManager::Load(const std::string &FileName) { m_bIsOk = true; m_FileName = FileName; CXMLTreeNode filexml; if (!filexml.LoadFile(FileName.c_str())) { //Guardar el mensaje de error en el LOGGER LOGGER->AddNewLog(ELL_ERROR, "CTriggerManager::Load ---Error al cargar el XML---"); m_bIsOk = false; } else { CXMLTreeNode triggers = filexml["triggers"]; int numNodes = triggers.GetNumChildren(); if (triggers.Exists()) { //<triggers> //<trigger name="Trigger_EntradaPuerta" entity="character" position="13.4664 0.0 -3.93624" max="-0.600954 4.70389 -1.79946" //min="0.600954 0.0 1.79946" active="true" onEnter="testEnter" onLeave="testLeave" rotation="" size="1.0"/> //</triggers> CTrigger* l_Trigger; for (int i = 0; i < numNodes; ++i) { if (!triggers(i).IsComment()) { //crea trigger info l_Trigger = new CTrigger(); l_Trigger->Init(); l_Trigger->SetName(triggers(i).GetPszProperty("name", "")); l_Trigger->SetEntity(triggers(i).GetPszProperty("entity", "")); l_Trigger->SetPosition(triggers(i).GetVect3fProperty("position", Vect3f(0.0f,0.0f,0.0f))); l_Trigger->SetMax(triggers(i).GetVect3fProperty("max", Vect3f(0.0f,0.0f,0.0f))); l_Trigger->SetMin(triggers(i).GetVect3fProperty("min", Vect3f(0.0f,0.0f,0.0f))); l_Trigger->SetActive(triggers(i).GetBoolProperty("active", false)); l_Trigger->SetTriggerActive(triggers(i).GetBoolProperty("active", false)); l_Trigger->SetOnEnterCode(triggers(i).GetPszProperty("onEnter", "")); l_Trigger->SetOnLeaveCode(triggers(i).GetPszProperty("onLeave", "")); l_Trigger->SetRotationX(triggers(i).GetFloatProperty("rotationX")); l_Trigger->SetRotationY(triggers(i).GetFloatProperty("rotationY")); l_Trigger->SetRotationZ(triggers(i).GetFloatProperty("rotationZ")); l_Trigger->SetSize(triggers(i).GetVect3fProperty("size", Vect3f(0.0f,0.0f,0.0f))); l_Trigger->SetDimensions(triggers(i).GetVect3fProperty("size", Vect3f(0.0f,0.0f,0.0f))); GeneraTrigger(l_Trigger->GetName(), l_Trigger, false); m_vTriggers.push_back(l_Trigger); } } } else { m_bIsOk = false; } } return m_bIsOk; }
CDirectionalLight::CDirectionalLight(CXMLTreeNode &TreeNode) :CLight(TreeNode) ,m_Direction(TreeNode.GetVect3fProperty("dir", v3fZERO)) ,m_OrthoShadowMapSize(TreeNode.GetVect2fProperty("ortho_shadow_map_size", v2fZERO)) ,m_PlayerOffset(TreeNode.GetVect3fProperty("player_offset", v3fZERO)) { m_Type = DIRECTIONAL; }
C3DElement::C3DElement(const CXMLTreeNode &XMLTreeNode) { const char *l_Pos=XMLTreeNode.GetPszProperty("pos", "0.0 0.0 0.0"); sscanf_s(l_Pos, "%f %f %f", m_Position[0], m_Position[1], m_Position[2]); m_Yaw=XMLTreeNode.GetFloatProperty("yaw", 0.0f); m_Pitch=XMLTreeNode.GetFloatProperty("pitch", 0.0f); m_Roll=XMLTreeNode.GetFloatProperty("roll", 0.0f); }
CScissorRectSceneRendererCommand::CScissorRectSceneRendererCommand(CXMLTreeNode &atts) : CSceneRendererCommand(atts) { m_Rect.left = atts.GetIntProperty("left",0); m_Rect.top = atts.GetIntProperty("top",0); m_Rect.right = atts.GetIntProperty("right",0); m_Rect.bottom = atts.GetIntProperty("bottom",0); }
SSphericalLimitInfo CPhysxSkeleton::GetJointParameterInfo(CXMLTreeNode _XMLObjects) { SSphericalLimitInfo l_sInfo; bool l_bTwistLimitLow = _XMLObjects.ExistsKey("TwistLimitLow"); bool l_bTwistLimitHigh = _XMLObjects.ExistsKey("TwistLimitHigh"); l_sInfo.JointSpring = _XMLObjects.ExistsKey("JointSpring"); l_sInfo.TwistSpring = _XMLObjects.ExistsKey("TwistSpring"); l_sInfo.SwingSpring = _XMLObjects.ExistsKey("SwingSpring"); l_sInfo.SwingLimit = _XMLObjects.ExistsKey("SwingLimit"); if (l_sInfo.JointSpring) { Vect2f l_vJointSpring = _XMLObjects.GetAttribute<Math::Vect2f>("JointSpring", Math::v2fZERO); l_sInfo.JointSpringValue = l_vJointSpring.x; l_sInfo.JointSpringDamper = l_vJointSpring.y; } if (l_sInfo.TwistSpring) { Vect2f l_vTwistSpring = _XMLObjects.GetAttribute<Math::Vect2f>("TwistSpring", Math::v2fZERO); l_sInfo.TwistSpringValue = l_vTwistSpring.x; l_sInfo.TwistSpringDamper = l_vTwistSpring.y; } if (l_sInfo.SwingSpring) { Vect2f l_vSwingSpring = _XMLObjects.GetAttribute<Math::Vect2f>("SwingSpring", Math::v2fZERO); l_sInfo.SwingSpringValue = l_vSwingSpring.x; l_sInfo.SwingSpringDamper = l_vSwingSpring.y; } if (l_sInfo.SwingLimit) { Vect2f l_vSwingLimit = _XMLObjects.GetAttribute<Math::Vect2f>("SwingLimit", Math::v2fZERO); l_sInfo.SwingValue = l_vSwingLimit.x; l_sInfo.SwingRestitution = l_vSwingLimit.y; } if (l_bTwistLimitLow && l_bTwistLimitHigh) { l_sInfo.TwistLimit = true; Vect2f l_vTwistLimitLow = _XMLObjects.GetAttribute<Math::Vect2f>("TwistLimitLow", Math::v2fZERO ); Vect2f l_vTwistLimitHigh = _XMLObjects.GetAttribute<Math::Vect2f>("TwistLimitHigh", Math::v2fZERO); l_sInfo.TwistLowValue = l_vTwistLimitLow.x; l_sInfo.TwistLowRestitution = l_vTwistLimitLow.y; l_sInfo.TwistHighValue = l_vTwistLimitHigh.x; l_sInfo.TwistHighRestitution = l_vTwistLimitHigh.y; } else { l_sInfo.TwistLimit = false; } return l_sInfo; }
void CVigia::InitTemplate(CXMLTreeNode& _XMLParams) { CEnemy::InitTemplate(_XMLParams); m_fAlarmActivate = (_XMLParams.GetBoolProperty("alarm_activate",false)); m_fEscudoActivate = (_XMLParams.GetBoolProperty("escudo_activate",false)); CEnemy::InitTemplate(_XMLParams); m_fAlarmActivate = (_XMLParams.GetBoolProperty("alarm_activate",false)); m_fEscudoActivate = (_XMLParams.GetBoolProperty("escudo_activate",false)); }
bool CParticleEmitterSystemManager::Reload() { CXMLTreeNode newFile; if (!newFile.LoadFile(m_Filename.c_str())) { std::string msg_error = "CParticleEmitterSystemManager::Load->Error al intentar leer el archivo xml: " + m_Filename; LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str()); return false; } CXMLTreeNode l_xml = newFile["particle_emitters_systems"]; if( l_xml.Exists() ) { uint16 l_Count = l_xml.GetNumChildren(); for(uint16 i=0; i<l_Count; ++i) { std::string l_Type = l_xml(i).GetName(); if( l_Type == "emitter_system" ) { std::string name = l_xml(i).GetPszProperty("name", "", true); assert(this->GetResource(name) == NULL); CParticleEmitterSystem* pes = new CParticleEmitterSystem(name); uint16 l_CountEmitters = l_xml(i).GetNumChildren(); CXMLTreeNode childs = l_xml(i); for(uint16 j=0; j<l_CountEmitters; ++j) { std::string l_ChildType = childs(j).GetName(); if(l_ChildType == "emitter") { std::string nameEmitter = childs(j).GetPszProperty("name", "", true); CParticleEmitter* pe = CORE->GetParticleEmitterManager()->GetResource(nameEmitter); pes->AddParticleEmitter(nameEmitter, pe); } } this->AddResource(name, pes); } } } else { return false; } return true; }
CCinematicComponent::CCinematicComponent(CXMLTreeNode& node, CElement* Owner) : CComponent(node, Owner) { SetNameFromParentName( Owner->getName() ); bool playAtStart = node.GetBoolProperty("playAtStart", false); if (playAtStart) { CEngine::GetSingleton().getCinematicManager()->Play(node.GetPszISOProperty("name","none")); } }
// -------------------------------------------- // CONSTRUCTOR/DESTRUCTOR // -------------------------------------------- CLensFlareSceneRemdererCommand::CLensFlareSceneRemdererCommand( CXMLTreeNode &_Node ) : CSceneRendererCommand ( _Node ) { m_LightIndex = _Node.GetIntProperty("light_index", 0, true); Vect3f glowColor = _Node.GetVect3fProperty("glow_color", v3fZERO, true); m_LensFlare = new CLensFlarePostProcess(); m_LensFlare->SetGlowColor(CColor(Vect4f(glowColor / 255.0f, 1.0f))); m_LensFlare->Init(); }
///<summary> /// CDrawQuadSceneEffect:: Constructor ///</summary> ///<param name="atts">Gestiona la lectura y escritura en ficheros XML</param> CDrawQuadSceneEffect::CDrawQuadSceneEffect(CXMLTreeNode &atts) : CSceneEffect (atts) , m_Technique (NULL) , m_Color (NULL) { //<post_render type="draw_quad" name="glow_post_effect" technique="RenderGlowPostFXTechnique" active="true" color="1.0 1.0 1.0 1.0"> // <texture stage_id="0" file="GlowTexture"/> //</post_render> CEffectManager *effm = CORE->GetEffectManager(); //TODO.. no devuelve la effectTechnique m_Technique = effm->GetEffectTechnique(atts.GetPszProperty("technique")); Vect4f l_vColor = atts.GetVect4fProperty("color", Vect4f(0.f,0.f,0.f,0.f)); m_Color.SetArgb(l_vColor); }
CStaticMesh::CStaticMesh(const CXMLTreeNode &TreeNode) : CNamed(TreeNode) , m_NumFaces(0) , m_NumVertexs(0) { Load(TreeNode.GetPszProperty("filename")); }
CAnimatedInstanceModel::CAnimatedInstanceModel(CXMLTreeNode &TreeNode):CRenderableObject(TreeNode) { Initialize(UABEngine.GetAnimatedModelsManager()->GetResource(TreeNode.GetPszProperty("core_name"))); /*m_AnimatedCoreModel = UABEngine.GetAnimatedModelsManager()->GetResource(l_Element.GetPszProperty("core_model_name")); m_CalModel = new CalModel(m_AnimatedCoreModel->GetCalCoreModel()); m_CalHardwareModel = new CalHardwareModel(m_AnimatedCoreModel->GetCalCoreModel());*/ }
//---------------------------------------------------------------------------- // Init data //---------------------------------------------------------------------------- bool CZombie::Init(const CXMLTreeNode &m) { m_bIsOk = Inherited::Init(m); if (!m_bIsOk) { LOGGER->AddNewLog(ELL_WARNING,"a CCZombie instace couldnt allocate memory"); } SetState( IDLE ); m_movIA = new CEjeMovimiento(); assert (m_movIA); m_bIsOk = m_movIA->Init(); if (!m_bIsOk) { LOGGER->AddNewLog(ELL_WARNING,"a CEjeMovimiento instace couldnt allocate memory"); } std::string l_sType = m.GetPszProperty("type", ""); if((l_sType.compare("ZOMBIE_BOSS"))&&(l_sType.compare("ZOMBIE_VOMITADOR"))) { if(m_bIsOk) { m_bIsOk = GeneraManoIzquierda(); } } if(l_sType.compare("ZOMBIE_VOMITADOR")) { if(m_bIsOk) { m_bIsOk = GeneraManoDerecha (); } } return m_bIsOk; }
CMaterial::CMaterial(CXMLTreeNode &TreeNode) : CNamed(TreeNode) { std::string l_EffectTechnique = TreeNode.GetPszProperty("effect_technique"); m_EffectTechnique = CEngine::GetSingletonPtr()->GetEffectManager()->GetResource(l_EffectTechnique); if (l_EffectTechnique == "diffuse_technique") { for (int i = 0; i < TreeNode.GetNumChildren(); ++i) { CXMLTreeNode l_Texture = TreeNode(i); CTexture * Texture = new CTexture(); Texture->Load(l_Texture.GetPszProperty("filename")); m_Textures.push_back(Texture); } } }
CEffectVertexShader::CEffectVertexShader(const CXMLTreeNode &TreeNode) : CEffectShader(TreeNode) , m_VertexShader(nullptr) , m_VertexLayout(nullptr) { m_VertexType = TreeNode.GetPszProperty("vertex_type"); }
CDialogBox::CDialogBox( const CXMLTreeNode& aNode, const Math::Vect2i& screenResolution ) : CGuiElement( aNode, screenResolution ) , m_bDialogClicked(false) , m_ButtonClose( aNode, screenResolution) //, m_ButtonMove( aNode, screenResolution ) , m_pBackGroundTexture(aNode.GetAttribute<CTexture>( "quad" )) , m_BackGroundColor(Math::colWHITE) , m_bStart_to_Move(false) , m_PreviousPosMouse(Math::v2iZERO) , m_fButtonHeight( 0.0f ) , m_fButtonWidth( 0.0f ) { m_ButtonClose.SetParent(this); m_ButtonClose.SetName("buttonClose"); m_ButtonClose.SetLiteral( "" ); m_ButtonClose.SetTextures ( aNode.GetAttribute<CTexture>( "buttonClose_normal" ), aNode.GetAttribute<CTexture>( "buttonClose_over" ), aNode.GetAttribute<CTexture>( "buttonClose_clicked" ), aNode.GetAttribute<CTexture>( "buttonClose_deactivated" ) ); m_ButtonClose.SetPositionPercent(m_PositionPercent + aNode.GetAttribute<Math::Vect2f>("pos_button", Math::Vect2f(0,0))); m_ButtonClose.SetWidthPercent(aNode.GetAttribute<float>("width_button",0.0f)); m_ButtonClose.SetHeightPercent(aNode.GetAttribute<float>("height_button", 0.0f)); for ( int i = 0, count = aNode.GetNumChildren(); i < count; ++i ) { CXMLTreeNode SubTreeNode = aNode( i ); const std::string& TagName = SubTreeNode.GetName(); if( TagName == "Dialog" ) { CStaticText* lTexto1 = new CStaticText(SubTreeNode(0), screenResolution ); CStaticText* lTexto2 = new CStaticText(SubTreeNode(1), screenResolution ); CStaticText* lTexto3 = new CStaticText(SubTreeNode(2), screenResolution ); lTexto1->SetPositionPercent(m_PositionPercent + lTexto1->GetPositionPercent()); lTexto2->SetPositionPercent(m_PositionPercent + lTexto2->GetPositionPercent()); lTexto3->SetPositionPercent(m_PositionPercent + lTexto3->GetPositionPercent()); CDialog* lDialog = new CDialog(lTexto1, lTexto2, lTexto3); m_Dialogo.push_back(lDialog); } } m_CurrentDialog = m_Dialogo.begin(); }
CSetRenderTargetSceneRendererCommand::CSetRenderTargetSceneRendererCommand(CXMLTreeNode &TreeNode) :CStagedTexturedSceneRendererCommand(TreeNode) { setName(TreeNode.GetPszProperty("name")); for (int i = 0; i < TreeNode.GetNumChildren(); i++){ CXMLTreeNode text = TreeNode(i); if (text.GetName()==std::string("dynamic_texture")) { //XML SceneRenderCommands: //<dynamic_texture name="DiffuseMapTexture" texture_width_as_frame_buffer="true" format_type="A8R8G8B8" create_depth_stencil_buffer="false"/> CDynamicTexture * dynText = new CDynamicTexture(text); m_DynamicTextures.push_back(dynText); CEngine::GetSingleton().getTextureManager()->add(dynText->getName(), dynText); } } CreateRenderTargetViewVector(); }
CRenderableObjectTechniquesSceneRendererCommand::CRenderableObjectTechniquesSceneRendererCommand(CXMLTreeNode &atts) : CSceneRendererCommand(atts) { std::string l_PROTName = atts.GetPszProperty("pool",""); if (l_PROTName!="") { m_PoolRenderableObjectTechnique = CORE->GetRenderableObjectsTechniqueManager()->GetPoolRenderableObjectTechniques().GetResource(l_PROTName); } }
CFreeCameraComponent::CFreeCameraComponent(CXMLTreeNode& node, CElement* Owner) : CComponent(node, Owner) { SetNameFromParentName( Owner->getName() ); m_camController = new CFreeCameraController(); Vect3f fwd = node.GetVect3fProperty("forward", Vect3f( 1, 0, 0), false); Vect3f off = node.GetVect3fProperty( "offset", Vect3f( 0, 0, 0 ), false ); float fov = node.GetFloatProperty( "fov", -1, false ); m_camController->SetForward( fwd ); m_camController->SetOffset( off ); if ( fov > 0 ) { m_camController->SetFOV( mathUtils::Deg2Rad(fov)/2 ); } }
CBillboardAnimation::CBillboardAnimation(CXMLTreeNode &parser){ SetColor(CColor(parser.GetVect3fProperty("color",Vect3f(1.0f)))); float size=parser.GetFloatProperty("size",2.0f); SetHeight(size); SetWidth(size); m_TimePerImage=parser.GetFloatProperty("time",0.2f); m_Loop=parser.GetBoolProperty("loop",false); CXMLTreeNode l_Node = parser["Textures"]; for(int i=0;i<l_Node.GetNumChildren();i++){ std::string l_TexturePath=l_Node(i).GetPszProperty("tex",""); CTexture *l_Texture = CORE->GetTextureManager()->GetTexture(l_TexturePath); m_Textures.push_back(l_Texture); } m_Index=0; m_fTime=0.0f; SetTexture(m_Textures[m_Index]); SetPos(Vect3f(0.0f,0.0f,0.0f)); }
bool CParticleSystemManager::Reload() { CXMLTreeNode newFile; if (!newFile.LoadFile(m_Filename.c_str())) { std::string msg_error = "CParticleSystemManager::Load->Error al intentar leer el archivo xml: " + m_Filename; LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str()); return false; } CXMLTreeNode l_xml = newFile["particle_systems"]; if( l_xml.Exists() ) { uint16 l_Count = l_xml.GetNumChildren(); for(uint16 i=0; i<l_Count; ++i) { std::string l_Type = l_xml(i).GetName(); if( l_Type == "system" ) { std::string name = l_xml(i).GetPszProperty("name", "", true); std::string settingsName = l_xml(i).GetPszProperty("settings_name", "", true); TParticleSystemSettings* settings = CORE->GetParticleSettingsManager()->GetResource(settingsName); assert(settings); CParticleSystem* system = new CParticleSystem(name, settings); bool isOk = this->AddResource(name, system); assert(isOk); } } } else { return false; } return true; }
CBillboardAnimation::CBillboardAnimation ( CXMLTreeNode &_Node ) : m_fTimePerImage ( 0.f ) , m_fCurrentTime ( 0.f ) , m_uiImage ( 0 ) , m_vColor ( Vect4f(0.f,0.f,0.f,0.f) ) , m_fSize ( 0.f ) , m_uiNumTextures ( 0 ) , m_bLoop ( false ) { m_Name = _Node.GetPszProperty ( "name", "" ); m_vColor = _Node.GetVect4fProperty( "color", Vect4f(0.f,0.f,0.f,0.f) ); m_fSize = _Node.GetFloatProperty("size", 1.f); m_fTimePerImage = _Node.GetFloatProperty("timePerImage", 1.f); m_bLoop = _Node.GetBoolProperty("loop", false); uint16 l_TotalAnimationNodes = _Node.GetNumChildren (); for ( uint16 i = 0; i < l_TotalAnimationNodes; ++i ) { std::string l_Node = _Node(i).GetName(); if ( l_Node == "Texture" ) { std::string l_TextureName = _Node(i).GetPszProperty("file", ""); CTexture *l_Tex = CORE->GetTextureManager()->GetTexture( l_TextureName ); m_vTextures.push_back( l_Tex ); } } m_uiNumTextures = m_vTextures.size(); }