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;
}
示例#2
0
bool CSceneRendererStep::InitMaterialEffects(CXMLTreeNode& _treeMaterialEffects)
{
  if(!_treeMaterialEffects.Exists())
    return false;

  m_szParticleEffect = _treeMaterialEffects.GetPszISOProperty("particle_effect","",false);

  if(_treeMaterialEffects.ExistsProperty("static_mesh_effect") && _treeMaterialEffects.ExistsProperty("animated_model_effect"))
  {
    m_szStaticMeshEffect = _treeMaterialEffects.GetPszISOProperty("static_mesh_effect","",false);
    m_szAnimatedModelEffect = _treeMaterialEffects.GetPszISOProperty("animated_model_effect","",false);
    

    m_bUseMap = false;

  }else{

    m_bUseMap = true;

    int l_iNumRenderTargets = _treeMaterialEffects.GetNumChildren();

    for(int l_iIndex = 0; l_iIndex < l_iNumRenderTargets;l_iIndex++)
    {
      CXMLTreeNode l_pMaterialEffect = _treeMaterialEffects(l_iIndex);

      if(string(l_pMaterialEffect.GetName()) == "material_effect")
      {
        int l_iMaterialType = l_pMaterialEffect.GetIntProperty("material_type",0,false);
        string l_szEffectName = l_pMaterialEffect.GetPszISOProperty("effect","",false);

        if(l_szEffectName != "")
        {
          m_mapMaterialEffects[l_iMaterialType] = l_szEffectName;
        }else{
          LOGGER->AddNewLog(ELL_WARNING,"CSceneRendererStep::InitMaterialEffects material type %d amb effecte null",l_iMaterialType);
        }

      }else if(!l_pMaterialEffect.IsComment())
      {
        LOGGER->AddNewLog(ELL_WARNING,"CSceneRendererStep::InitMaterialEffects element no reconegut %s",l_pMaterialEffect.GetName());
      }

    }
  }

  return true;
}
示例#3
0
bool CEffect::Init(const CXMLTreeNode& _xmlEffect, LPD3DXEFFECTPOOL _pEffectPool)
{
  SetOk(true);

  string l_szName = _xmlEffect.GetPszISOProperty("name","");

  if(l_szName.compare("") == 0)
  {
    LOGGER->AddNewLog(ELL_ERROR,"CEffect::Init Empty name");
    SetOk(false);
    return false;
  }

  SetName(l_szName); 

  m_iTextureMask = _xmlEffect.GetIntProperty("texture_mask",0,false);

  m_szFileName = _xmlEffect.GetPszISOProperty("file","");

  if(m_szFileName.compare("") == 0)
  {
    LOGGER->AddNewLog(ELL_ERROR,"CEffect::Init Empty effect path");
    SetOk(false);
    return false;
  }

  m_szTechniqueName = _xmlEffect.GetPszISOProperty("technique","");

  if(m_szTechniqueName.compare("") == 0)
  {
    LOGGER->AddNewLog(ELL_ERROR,"CEffect::Init Empty technique name");
    SetOk(false);
    return false;
  }

  m_szInstancedTechniqueName = _xmlEffect.GetPszISOProperty("instanced_technique","", false);

  m_szD3DAlphaTechniqueName  = _xmlEffect.GetPszISOProperty("alpha_technique","", false);

  SetOk(LoadEffect(_pEffectPool));
  return IsOk();
}
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"));
	}
}
bool CPhysxSkeleton::AddSphericalJoint(CXMLTreeNode _XMLObjects)
{
  string l_szActor1,l_szActor2, l_szDirection;

  l_szActor1		= _XMLObjects.GetPszISOProperty("Actor1" ,"");
  l_szActor2		= _XMLObjects.GetPszISOProperty("Actor2" ,"");
  l_szDirection	= _XMLObjects.GetPszISOProperty("Direction" ,"");

  SSphericalLimitInfo l_pJointInfo = GetJointParameterInfo(_XMLObjects);

  CPhysxBone* l_pBone1 = GetPhysxBoneByName(l_szActor1);
  CPhysxBone* l_pBone2 = GetPhysxBoneByName(l_szActor2);

  CPhysicActor* l_pActor1 = 0;
  CPhysicActor* l_pActor2 = 0;
  l_pActor1 = l_pBone1->GetPhysxActor();

  CPhysicSphericalJoint* l_pSphericalJoint = 0;
  l_pSphericalJoint = new CPhysicSphericalJoint();


  CalVector l_vCalVect = l_pBone1->GetCalBone()->getTranslationAbsolute();
  Vect3f l_vJointPoint(-l_vCalVect.x,l_vCalVect.y,l_vCalVect.z);
  l_vJointPoint = m_mTransform*l_vJointPoint;
  Vect3f l_vAxis;
  CalVector l_vVect;

  

  //MES PROVES
  if (l_szDirection == "Out")
  {
    if (l_pBone1->GetChildList().size() > 0)
    {
      int l_pChildId = l_pBone1->GetChildList()[0];
      string l_szNameChild = m_pCalSkeleton->getBone(l_pChildId)->getCoreBone()->getName();
      CPhysxBone* l_pPhysChild = GetPhysxBoneByName(l_szNameChild);
      l_vVect = l_pPhysChild->GetCalBone()->getTranslationAbsolute();
      l_vVect.x = -l_vVect.x;
    /*  l_vAxis = Vect3f(l_vVect.x-l_vJointPoint.x,l_vVect.y-l_vJointPoint.y,l_vVect.z-l_vJointPoint.z);
      l_vAxis.Normalize();*/
    }
    else
    {
      Vect3f l_vMiddle = l_pBone1->GetMiddlePoint();
      l_vVect = CalVector(l_vMiddle.x,l_vMiddle.y,l_vMiddle.z);
      /*l_vAxis(l_vMiddle.x-l_vJointPoint.x,l_vMiddle.y-l_vJointPoint.y,l_vMiddle.z-l_vJointPoint.z);
      l_vAxis.Normalize();*/
    }
  }
  else if (l_szDirection == "In")
  {
    if (!l_pBone1->IsBoneRoot())
    {
      int l_pParentID = l_pBone1->GetParentID();
      string l_szNameParent = m_pCalSkeleton->getBone(l_pParentID)->getCoreBone()->getName();
      CPhysxBone* l_pPhysParent = GetPhysxBoneByName(l_szNameParent);
      CalVector l_vVect = l_pPhysParent->GetCalBone()->getTranslationAbsolute();
      l_vVect.x = -l_vVect.x;
     /* l_vAxis = Vect3f(l_vVect.x-l_vJointPoint.x,l_vVect.y-l_vJointPoint.y,l_vVect.z-l_vJointPoint.z);
      l_vAxis.Normalize();*/
    }
    
  }

  
  Vect3f l_vAxisAux(l_vVect.x,l_vVect.y,l_vVect.z);
  l_vAxisAux = m_mTransform*l_vAxisAux;
  l_vAxis = Vect3f(l_vAxisAux.x-l_vJointPoint.x,l_vAxisAux.y-l_vJointPoint.y,l_vAxisAux.z-l_vJointPoint.z);
  l_vAxis.Normalize();

  l_pJointInfo.m_vAnchor = l_vJointPoint;
  l_pJointInfo.m_vAxis = l_vAxis;



  if (l_szActor2=="NULL")
  {
    //l_pSphericalJoint->SetInfoComplete(l_vJointPoint,l_vAxis,l_pActor1);
    l_pSphericalJoint->SetInfoRagdoll(l_pJointInfo,l_pActor1);
  }
  else
  {
    l_pActor2 = l_pBone2->GetPhysxActor();
    //l_pSphericalJoint->SetInfoComplete(l_vJointPoint,l_vAxis,l_pActor1,l_pActor2);
    l_pSphericalJoint->SetInfoRagdoll(l_pJointInfo,l_pActor1,l_pActor2);
  }
  CORE->GetPhysicsManager()->AddPhysicSphericalJoint(l_pSphericalJoint);
  m_vSphericalJoints.push_back(l_pSphericalJoint);

	return true;
}
示例#6
0
bool CTextureRenderTarget::Init(CXMLTreeNode& _treeRenderTarget)
{
  string l_szName =  _treeRenderTarget.GetPszISOProperty("name","",false);
  string l_szTextureName = _treeRenderTarget.GetPszISOProperty("texture","",false);
  string l_szFormat = _treeRenderTarget.GetPszISOProperty("format","A8R8G8B8");

  int l_iWidth = (int)CORE->GetRenderManager()->GetScreenWidth();

  float l_fSize = _treeRenderTarget.GetFloatProperty("size",1.f,false);

  m_iWidth  = _treeRenderTarget.GetIntProperty("width" ,(int)(RENDER_MANAGER->GetScreenWidth()  * l_fSize),false);
  m_iHeight = _treeRenderTarget.GetIntProperty("height",(int)(RENDER_MANAGER->GetScreenHeight() * l_fSize),false);

  CRenderTarget::Init(m_iWidth, m_iHeight);

  SetOk(true);

  if(l_szName != "")
  {
    SetName(l_szName);

    if(l_szTextureName != "")
    {
      m_szTextureName = l_szTextureName;

      CTexture* l_pTexture = new CTexture();

      if(l_pTexture->Create(l_szTextureName,
                            m_iWidth,
                            m_iHeight,
                            1,
                            CTexture::RENDERTARGET,
                            CTexture::DEFAULT,
                            CTexture::GetFormatTypeFromString(l_szFormat)))
      {
        m_pSurface = l_pTexture->GetSurface();
        m_pSurface->AddRef();
      } else
      {
        m_pSurface = 0;
      }

      if(l_pTexture->IsOk() && m_pSurface)
      {
        SetOk(true);
        CORE->GetTextureManager()->AddResource(l_szTextureName, l_pTexture);
      } else
      {
        if(!l_pTexture->IsOk())
          LOGGER->AddNewLog(ELL_ERROR, "CTextureRenderTarget::Init  Texture is not Ok.");
        if(!m_pSurface)
          LOGGER->AddNewLog(ELL_ERROR, "CTextureRenderTarget::Init  Surface is not Ok.");
        SetOk(false);
        CHECKED_DELETE(l_pTexture);
      }

    }else{
      LOGGER->AddNewLog(ELL_WARNING,"CTextureRenderTarget::Init render_target sense textura");
      SetOk(false);
    }
  }else{
    LOGGER->AddNewLog(ELL_WARNING,"CTextureRenderTarget::Init render_target sense nom");
    SetOk(false);
  }
          
  return IsOk();
}
示例#7
0
bool CPostSceneRendererStep::Init(CXMLTreeNode& _treePostSceneRenderer, const string& _szDefaultRenderTarget, bool _bNeedsEffect)
{
    string l_szEffect = _treePostSceneRenderer.GetPszISOProperty("effect","",!_bNeedsEffect);

    if(!CRendererStep::Init(_treePostSceneRenderer, _szDefaultRenderTarget))
    {
        LOGGER->AddNewLog(ELL_ERROR,"CPostSceneRendererStep::Init PostSceneRenderer sense nom");
        SetOk(false);
    } else if(l_szEffect == "" && _bNeedsEffect)
    {
        LOGGER->AddNewLog(ELL_ERROR,"CPostSceneRendererStep::Init PostSceneRenderer sense effect");
        SetOk(false);
    } else {

        LOGGER->AddNewLog(ELL_INFORMATION,"CPostSceneRendererStep::Init iniciant %s",GetName().c_str());

        CRendererStep::Init(_treePostSceneRenderer, _szDefaultRenderTarget);

        CXMLTreeNode l_treeSamplers = _treePostSceneRenderer.GetChild("input_samplers");
        CXMLTreeNode l_treeRenderTargets = _treePostSceneRenderer.GetChild("render_targets");

        if(!InitInputSamplers(l_treeSamplers))
        {
            LOGGER->AddNewLog(ELL_ERROR,"CPostSceneRendererStep::Init error inicialitzant input_samplers");
            SetOk(false);
        } else {

            m_szEffect = l_szEffect;

            m_bUseTime = _treePostSceneRenderer.GetBoolProperty("use_time",false,false);

            if(m_bUseTime)
            {
                m_bUseDeltaTime = _treePostSceneRenderer.GetBoolProperty("use_delta_time",false,false);
            }
            else
            {
                m_bUseDeltaTime = false;
            }

            m_bUseCenter = _treePostSceneRenderer.GetBoolProperty("use_center",false,false);

            string l_szAlignment = _treePostSceneRenderer.GetPszISOProperty("alignment","",false);
            if(l_szAlignment == "center")
            {
                m_Alignment = CENTER;
            }

            Vect2f l_fPos = _treePostSceneRenderer.GetVect2fProperty("position",Vect2f(0),false);

            m_iPos.x = (int) (l_fPos.x * RENDER_MANAGER->GetScreenWidth());
            m_iPos.y = (int) (l_fPos.y * RENDER_MANAGER->GetScreenHeight());

            if(_treePostSceneRenderer.ExistsProperty("size"))
            {
                float l_fSizeX = _treePostSceneRenderer.GetFloatProperty("size",1.0,false);

                if(_treePostSceneRenderer.GetBoolProperty("absolute_size",false,false))
                {
                    m_iSize.x = (int) l_fSizeX;
                    m_iSize.y = m_iSize.x;
                }
                else
                {
                    m_iSize.x = (int) (l_fSizeX * RENDER_MANAGER->GetScreenWidth());
                    m_iSize.y = m_iSize.x;
                }

                if(_treePostSceneRenderer.ExistsProperty("aspect_ratio"))
                {
                    bool l_bAspectRatio = _treePostSceneRenderer.GetBoolProperty("aspect_ratio",true,false);

                    if(l_bAspectRatio)
                    {
                        m_iSize.y = (int)(m_iSize.x * RENDER_MANAGER->GetScreenHeight()/(float)RENDER_MANAGER->GetScreenWidth());
                    }
                }

            } else if(_treePostSceneRenderer.ExistsProperty("size_x"))
            {
                float l_fSizeX = _treePostSceneRenderer.GetFloatProperty("size_x",1.0,false);
                float l_fSizeY = _treePostSceneRenderer.GetFloatProperty("size_y",1.0,false);

                if(_treePostSceneRenderer.GetBoolProperty("absolute_size",false,false))
                {
                    m_iSize.x = (int) l_fSizeX;
                    m_iSize.y = (int) l_fSizeY;
                }
                else
                {
                    m_iSize.x = (int) (l_fSizeX * RENDER_MANAGER->GetScreenWidth());
                    m_iSize.y = (int) (l_fSizeY * RENDER_MANAGER->GetScreenHeight());
                }

            } else
            {
                m_iSize.x = RENDER_MANAGER->GetScreenWidth();
                m_iSize.y = RENDER_MANAGER->GetScreenHeight();
            }

            SetOk(true);
        }
    }

    return IsOk();
}