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();
}
