bool CRenderObjectsPostSceneRendererStep::Init(CXMLTreeNode& _treePostSceneRenderer, const string& _szDefaultRenderTarget)
{
LOGGER->AddNewLog(ELL_INFORMATION,"CRenderObjectsPostSceneRendererStep::Init");
//bool l_bOk = CPostSceneRendererStep::Init(_treePostSceneRenderer,_szDefaultRenderTarget, false);
//if(!l_bOk)
// return false;
SetOk(true);
m_pSceneRendererStep = new CSceneRendererStep();
if(!m_pSceneRendererStep->Init(_treePostSceneRenderer,_szDefaultRenderTarget))
{
delete m_pSceneRendererStep;
SetOk(false);
}
else
{
SetName(m_pSceneRendererStep->GetName());
m_iSize.x = RENDER_MANAGER->GetScreenWidth();
m_iSize.y = RENDER_MANAGER->GetScreenHeight();
m_szRenderTarget = m_pSceneRendererStep->GetRenderTarget();
}
return IsOk();
}
bool CPhysxSkeleton::Init(const string& _szFileName, CalModel* _pCalModel, Mat44f _vMat, int _iColisionGroup, CGameEntity *_pEntity)
{
m_pEntity = _pEntity;
m_mTransform = _vMat;
_pCalModel->getSkeleton()->calculateState();
SetSkeleton(_pCalModel->getSkeleton());
vector<CalBone*> l_vLlistaBones = m_pCalSkeleton->getVectorBone();
//Inicialitzem l'estructura del PhysXSkeleton i creem les instancies dels PhysXBones.
//Tindrem ja tota la info relativa de bones, pares i fills.
for (size_t i=0;i<l_vLlistaBones.size();++i)
{
CalBone* l_pBone = l_vLlistaBones[i];
CPhysxBone* l_pPhysXBone = new CPhysxBone(l_pBone->getCoreBone()->getName());
l_pPhysXBone->Init(l_pBone,_vMat,_iColisionGroup);
m_vBones.push_back(l_pPhysXBone);
}
//Load la info del XML I POSA ELS ACTORS!!!!
Load(_szFileName);
InitParents();
InitPhysXJoints(_szFileName);
SetOk(true);
return IsOk();
}
bool CComponentPhysXController::Init(CGameEntity *_pEntity,
float radius, float height, float slope, float skinwidth,
float stepOffset, uint32 _iCollisionGroup
)
{
CPhysicsManager *l_pPM = CORE->GetPhysicsManager();
m_pObject3D = _pEntity->GetComponent<CComponentObject3D>(ECT_OBJECT_3D);
assert(m_pObject3D); //TODO fer missatges d'error més elavorats
m_pMovement = _pEntity->GetComponent<CComponentMovement>(ECT_MOVEMENT);
assert(m_pMovement); //TODO fer missatges d'error més elavorats
m_pPhysXData = new CPhysicUserData(_pEntity->GetName().c_str());
m_pPhysXData->SetPaint(true);
m_pPhysXData->SetColor(colGREEN);
m_pPhysXData->SetEntity(_pEntity);
m_pPhysXController = new CPhysicController(
radius, height, slope, skinwidth, stepOffset,
l_pPM->GetCollisionMask( (ECollisionGroup) _iCollisionGroup ),
m_pPhysXData,
m_pObject3D->GetPosition());
m_pPhysXController->SetPitch(m_pObject3D->GetPitch());
m_pPhysXController->SetYaw (m_pObject3D->GetYaw() );
m_pPhysXController->SetRoll (m_pObject3D->GetRoll() );
l_pPM->AddPhysicController(m_pPhysXController);
m_pPhysXController->SetGroup(_iCollisionGroup);
SetOk(true);
return IsOk();
}
bool CComponentPlayerController::Init(CGameEntity *_pEntity)
{
m_pMovement = _pEntity->GetComponent<CComponentMovement>(ECT_MOVEMENT);
assert(m_pMovement); //TODO fer missatges d'error més elavorats
m_pObject3D = _pEntity->GetComponent<CComponentObject3D>(ECT_OBJECT_3D);
assert(m_pObject3D); //TODO fer missatges d'error més elavorats
CComponentRenderableObject *l_pComponentRO = _pEntity->GetComponent<CComponentRenderableObject>(ECT_RENDERABLE_OBJECT);
assert(l_pComponentRO); //TODO fer missatges d'error més elavorats
m_pAnimatedModel = dynamic_cast<CRenderableAnimatedInstanceModel*>(l_pComponentRO->GetRenderableObject());
assert(m_pAnimatedModel); //TODO fer missatges d'error més elavorats
m_bGodMode =
m_bSemigodMode =
m_bShootActive =
m_bGrenadeActive =
m_bForceActive = false;
m_vPickUps.clear();
m_pForceEmiter1 = ENTITY_MANAGER->InitParticles("electric_small", Vect3f( 1,0,0), Vect3f(.15f));
m_pForceEmiter2 = ENTITY_MANAGER->InitParticles("electric_small", Vect3f(-1,0,0), Vect3f(.15f));
SetOk(true);
return IsOk();
}
bool CEngine::Init(const SInitParams& _InitParams, HWND hWnd)
{
LOGGER->AddNewLog(ELL_INFORMATION,"Engine::Init");
m_pCore = new CCore();
bool result = m_pCore->Init(hWnd, _InitParams);
if(!result)
{
LOGGER->SaveLogsInFile();
}
assert(result);
if(m_pActiveProcess) //TODO: Comprovar excepcio m_pProcess == NULL i logejar
{
m_pActiveProcess->Init();
m_pActiveProcess->RegisterLuaFunctions();
}
m_pCore->GetActionManager()->SetProcess(m_pActiveProcess);
SetOk(true);
return IsOk();
}
bool CComponentTrigger::Init(
CGameEntity* _pEntity,
const Vect3f& _vSize,
const string& _szOnEnter, const string& _szOnExit,
int _iCollisionGroup)
{
m_pObject3D = _pEntity->GetComponent<CComponentObject3D>(ECT_OBJECT_3D);
assert(m_pObject3D); //TODO fer missatges d'error més elavorats
m_pPhysXData = new CPhysicUserData(_pEntity->GetName().c_str());
m_pPhysXData->SetPaint(true);
m_pPhysXData->SetColor(colYELLOW);
m_pPhysXData->SetEntity(_pEntity);
m_pPhysXActor = new CPhysicActor(m_pPhysXData);
m_pPhysXActor->CreateBoxTrigger(m_pObject3D->GetMat44().GetPos(), _vSize * .5f, _iCollisionGroup);
CORE->GetPhysicsManager()->AddPhysicActor(m_pPhysXActor);
m_pPhysXActor->SetMat44( m_pObject3D->GetMat44() );
m_szOnEnter = _szOnEnter;
m_szOnExit = _szOnExit;
m_sEntered.clear();
SetOk(true);
return IsOk();
}
void CEnemyInstance::InitInstance(CXMLTreeNode& _XMLParams)
{
m_vPosition = _XMLParams.GetVect3fProperty("pos",Vect3f(0.0f));
m_vRotate = _XMLParams.GetVect3fProperty("rot",Vect3f(0.0f));
SetOk(true);
}
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();
}
bool CComponentStateMachine::Init(CGameEntity* _pEntity, const string& _pEstatInicial)
{
m_pStateMachine = new CScriptedStateMachine(_pEntity,_pEstatInicial,"");
m_pStateMachine->SetCurrentState(_pEstatInicial);
m_bUpdatePause = false;
SetOk(true);
return IsOk();
}
bool CComponentEnergy::Init(CGameEntity* _pEntity, float _fInitialEnergy, float _fMaxEnergy, float _fRegenAmount, float _fTimeForRegen)
{
m_fEnergy = _fInitialEnergy;
m_fMaxEnergy = _fMaxEnergy;
m_fRegenAmount = _fRegenAmount;
m_fTimeForRegen = _fTimeForRegen;
m_fTimeSinceUsed = 0.0f;
SetOk(true);
return IsOk();
}
//yaw pitch roll
bool CComponentRotative::Init(CGameEntity* _pEntity, float _fYawRotation, float _fPitchRotation, float _fRollRotation)
{
m_fYawRotation = _fYawRotation;
m_fPitchRotation = _fPitchRotation;
m_fRollRotation = _fRollRotation;
m_pCRO = _pEntity->GetComponent<CComponentRenderableObject>();
if(m_pCRO)
{
SetOk(true);
}
else
{
LOGGER->AddNewLog(ELL_ERROR, "CComponentRotative::Init No s'ha trobat cap component renderable object.");
SetOk(false);
}
return IsOk();
}
bool CTextureManager::Init ()
{
m_pDefaultTexture = new CTexture();
SetOk(false);
if(m_pDefaultTexture->Create("DefaultTexture",
32,
32,
0,
CTexture::DYNAMIC,
CTexture::DEFAULT,
CTexture::A8R8G8B8))
{
if(m_pDefaultTexture->FillDefaultTexture())
{
SetOk( true );
}
}
if(IsOk())
{
m_pDefaultCubeTexture = new CTexture();
if(!m_pDefaultCubeTexture->CreateDefaultCube(m_pDefaultTexture))
{
SetOk(false);
}
}
if(!IsOk())
{
std::string msg_error = "CTextureManager::Init-> Error al intentar crear la defualtTexture en la inicialización de CTextureManager";
LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str());
Release();
//throw CException(__FILE__, __LINE__, msg_error);
}
else
{
AddResource("default", m_pDefaultTexture);
AddResource("default cube", m_pDefaultCubeTexture);
}
return IsOk();
}
bool CBiotestProcess::Init()
{
LOGGER->AddNewLog(ELL_INFORMATION,"CBiotestProcess::Init");
// ------------------------- noves partícules ----------------------------------------
//m_pCoreEmiterManager = new CCoreEmiterManager();
//m_pCoreEmiterManager->Load("Data/XML/CoreEmiters.xml");
m_pEmiter = new CEmiterInstance();
m_pEmiter->Init("bubble", CObject3D(Vect3f(-14.6275f, 0.833153f, -4.08485f),0,0), Vect3f(0.391403f, 0.702762f, 0.194437f));
// -----------------------------------------------------------------------------------
//m_pSceneEffectManager = CORE->GetSceneEffectManager();
CORE->GetLightManager()->SetLightsEnabled(true);
CORE->GetEntityManager()->LoadEntitiesFromXML("Data/Levels/Level -2/XML/GameEntities - Laboratori.xml");
CORE->GetEntityManager()->LoadEntitiesFromXML("Data/Levels/Level -2/XML/GameEntities - Menjador.xml");
CORE->GetEntityManager()->LoadEntitiesFromXML("Data/Levels/Level -2/XML/GameEntities - Passadis.xml");
CORE->GetEntityManager()->LoadEntitiesFromXML("Data/Levels/Level -2/XML/GameEntities - video.xml");
CORE->GetEntityManager()->CreateLevelControllerEntity(false);
CGameEntity* l_pPlayerEntity = CORE->GetEntityManager()->GetEntity("Player");
m_pCamera = l_pPlayerEntity->GetComponent<CComponent3rdPSCamera>()->GetCamera();
/*Vect3f l_vOmniColor = Vect3f(.5f,.5f,.5f);
m_pOmniLight = CORE->GetLightManager()->CreateOmniLight("OmniViewerLight",Vect3f(0.0f),CColor(l_vOmniColor),0.1f,17.0f);
m_pOmniLight->SetActive(true);*/
CORE->GetIAManager()->CompleteGraph();
m_pSpotLight = CORE->GetLightManager()->CreateSpotLight("FreeModeLight",
Vect3f(0.0f,15.0f,0.0f),
Vect3f(0.3f,-1.0f,0.0f),
CColor(Vect3f(1.0f,1.0f,1.0f)),
20.0f,
80.0f,
10.0f,
45.0f,
false );
m_pSpotLight->SetActive(true);
SetOk(true);
return IsOk();
}
bool CComponentDestroyable::Init(CGameEntity* _pEntity, const string& _szAction, const string& _szResource)
{
//és necessari un component de vida
assert(_pEntity->GetComponent<CComponentVida>(ECT_VIDA));
m_szAction = _szAction;
m_szResource = _szResource;
m_bDestroyed = false;
SetOk(true);
return IsOk();
}
bool CComponentShield::Init(CGameEntity* _pEntity, float _fHP, float _fMaxHP, float _fRegenAmount, float _fCooldown)
{
m_fHP = _fHP;
m_fMaxHP = _fMaxHP;
m_fRegenAmount = _fRegenAmount;
m_fCooldown = _fCooldown;
m_fTime = m_fCooldown;
//m_bActive = false;
SetOk(true);
return IsOk();
}
bool CComponentLifetime::Init(CGameEntity *_pEntity, float _fTime, const string& _szScript)
{
assert(_fTime >= 0);
m_fTargetTime = _fTime;
m_szScript = _szScript;
m_bTriggered = false;
SetOk(true);
return IsOk();
}
void CAnimatedInstanceModel::Initialize(CAnimatedCoreModel *_pAnimatedCoreModel)
{
if(_pAnimatedCoreModel != NULL)
{
LOGGER->AddNewLog(ELL_INFORMATION,"CAnimatedInstanceModel::Initialize Inicialitzant un AnimatedCoreModel.");
m_pAnimatedCoreModel = _pAnimatedCoreModel;
CalCoreModel* l_pCoreModel = m_pAnimatedCoreModel->GetCoreModel();
m_pCalModel = new CalModel(l_pCoreModel);
//m_iNumVtxs = 0;
//m_iNumFaces = 0;
int l_iMeshCount = l_pCoreModel->getCoreMeshCount();
for(int l_iMeshId = 0; l_iMeshId < l_iMeshCount; l_iMeshId++)
{
LOGGER->AddNewLog(ELL_INFORMATION,"CAnimatedInstanceModel::Initialize Afegint mesh %d.", l_iMeshId);
m_pCalModel->attachMesh(l_iMeshId);
//CalCoreMesh* l_pCoreMesh = l_pCoreModel->getCoreMesh(l_iMeshId);
//int l_iSubmeshCount = l_pCoreMesh->getCoreSubmeshCount();
//for(int l_iSubMeshId = 0; l_iSubMeshId < l_iSubmeshCount; l_iSubMeshId++)
//{
// m_iNumVtxs += l_pCoreMesh->getCoreSubmesh(l_iSubMeshId)->getVertexCount();
// m_iNumFaces += l_pCoreMesh->getCoreSubmesh(l_iSubMeshId)->getFaceCount();
//}
}
InitD3D(RENDER_MANAGER);
//animated vertex technique
//string l_szTechniqueName = RENDER_MANAGER->GetEffectManager()->GetTechniqueEffectNameByVertexDefault(TCAL3D_HW_VERTEX::GetVertexType());
//m_pEffectTechnique = RENDER_MANAGER->GetEffectManager()->GetEffectTechnique(l_szTechniqueName);
SetOk(true);
m_szAnimationState = _pAnimatedCoreModel->m_szDefaultAnimationState;
if(m_szAnimationState != "")
{
map<string, SAnimationState>::iterator l_it = _pAnimatedCoreModel->m_AnimationStates.find(m_szAnimationState);
if(l_it != _pAnimatedCoreModel->m_AnimationStates.end())
{
foreach(const SCycle& cycle, l_it->second.Cycles)
{
float l_fWeight = (cycle.bFromParameter)? m_fAnimationParameter : ((cycle.bFromComplementaryParameter)? 1 - m_fAnimationParameter : 1);
l_fWeight *= cycle.fWeight;
m_pCalModel->getMixer()->blendCycle(cycle.iId,l_fWeight,0.f);
}
} else {
bool CComponentDelayedScript::Reset(float _fTime, const string& _szScript)
{
assert(_fTime >= 0);
m_fTargetTime = _fTime;
m_szScript = _szScript;
m_bTriggered = false;
m_fTime = 0;
SetOk(true);
return IsOk();
}
bool CSceneRendererStep::Init(CXMLTreeNode& _treeSceneRenderer, const string& _szDefaultRenderTarget)
{
//string l_szName = _treeSceneRenderer.GetPszISOProperty("name","",false);
//string l_szRenderTarget = _treeSceneRenderer.GetPszISOProperty("render_target","",false);
if(!CRendererStep::Init(_treeSceneRenderer,_szDefaultRenderTarget))
{
LOGGER->AddNewLog(ELL_ERROR,"CSceneRendererStep::Init SceneRenderer sense nom");
SetOk(false);
}else{
LOGGER->AddNewLog(ELL_INFORMATION,"CSceneRendererStep::Init iniciant %s",GetName().c_str());
//CRendererStep::Init(l_szRenderTarget);
CXMLTreeNode l_treeSamplers = _treeSceneRenderer.GetChild("input_samplers");
CXMLTreeNode l_treeMaterialEffects = _treeSceneRenderer.GetChild("material_effects");
if(!InitInputSamplers(l_treeSamplers))
{
LOGGER->AddNewLog(ELL_ERROR,"CSceneRendererStep::Init error inicialitzant input_samplers");
SetOk(false);
}else if(!InitMaterialEffects(l_treeMaterialEffects))
{
LOGGER->AddNewLog(ELL_ERROR,"CSceneRendererStep::Init error inicialitzant els material_effects");
SetOk(false);
}else{
//SetName(l_szName);
SetOk(true);
}
}
return IsOk();
}
bool CComponentVida::Init(CGameEntity* _pEntity, float _fVidaInicial, float _fVidaMaxima, bool _bRegen, float _fRegenAmount, float _fTimeForRegen)
{
m_fVida = _fVidaInicial;
m_fVidaMaxima = _fVidaMaxima;
m_bRegen = _bRegen;
m_fRegenAmount = _fRegenAmount;
m_fTimeForRegen = _fTimeForRegen;
m_fTimeSinceHit = 0.0f;
m_fDoTTime = 0.0f;
m_fHoTTime = 0.0f;
m_pShield = _pEntity->GetComponent<CComponentShield>(ECT_SHIELD);
SetOk(true);
return IsOk();
}
bool CParticleProcess::Init()
{
m_pObject = new CObject3D();
m_fVelocity = 1;
angle=0;
m_pObject->SetPosition(Vect3f(-6,1.7f,0));
m_pObjectBot = CORE->GetRenderableObjectsManager()->GetResource("bot");
m_iState = 0;
m_bStateChanged = false;
m_pObjectCamera = new CThPSCamera(
0.1f,
100.0f,
35.0f * FLOAT_PI_VALUE/180.0f,
((float)RENDER_MANAGER->GetScreenWidth())/((float)RENDER_MANAGER->GetScreenHeight()),
m_pObject,
4.5f);
m_pCamera = m_pObjectCamera;
((CThPSCamera*)m_pObjectCamera)->SetZoom(10.0f);
//m_pSceneEffectManager = CORE->GetSceneEffectManager();
CSpotLight* l_Spot = (CSpotLight*)CORE->GetLightManager()->GetResource("Spot01");
if(l_Spot)
{
//l_Spot->SetDirection(m_pObjectBot->GetPosition());
l_Spot->SetActive(true);
}
m_bRenderLights = false;
SetOk(true);
return IsOk();
}
bool CComponentPhysXSphere::Init(CGameEntity *_pEntity, float _fRadius,
float _fPosX , float _fPosY , float _fPosZ,
float _fDensity, int _iCollisionGroup
)
{
m_fDensity = _fDensity;
m_iCollisionGroup = _iCollisionGroup;
m_pObject3D = _pEntity->GetComponent<CComponentObject3D>(ECT_OBJECT_3D);
assert(m_pObject3D); //TODO fer missatges d'error més elaborats
m_pPhysXData = new CPhysicUserData(_pEntity->GetName().c_str());
m_pPhysXData->SetPaint(true);
m_pPhysXData->SetColor(colBLUE);
m_pPhysXData->SetEntity(_pEntity);
m_pPhysXActor = new CPhysicActor(m_pPhysXData);
if(_fDensity > 0)
{
m_pPhysXActor->CreateBody(_fDensity);
}else{
m_pPhysXActor->CreateBody(100.0f);
}
m_pPhysXActor->AddSphereShape(_fRadius,v3fZERO,Vect3f( _fPosX , _fPosY , _fPosZ ), NULL, _iCollisionGroup);
CORE->GetPhysicsManager()->AddPhysicActor(m_pPhysXActor);
if(_fDensity == 0)
{
m_pPhysXActor->SetKinematic(true);
}
m_pPhysXActor->SetMat44( m_pObject3D->GetMat44() );
//m_vSize = Vect3f(_fSizeX, _fSizeY, _fSizeZ);
SetOk(true);
return IsOk();
}
bool CAnimatedModelManager::Load(const string &_szFileName)
{
LOGGER->AddNewLog(ELL_INFORMATION, "CAnimatedModelManager::Load Carregant el fitxer \"%s\"", _szFileName.c_str());
m_vXMLFiles.insert(_szFileName);
CXMLTreeNode l_treeAnimatedModels;
if(l_treeAnimatedModels.LoadFile(_szFileName.c_str()))
{
int l_iNumChildren = l_treeAnimatedModels.GetNumChildren();
for(int i = 0; i < l_iNumChildren; i++)
{
CXMLTreeNode l_treeAnimatedModel = l_treeAnimatedModels(i);
if(strcmp(l_treeAnimatedModel.GetName(),"animatedModel") == 0)
{
const char* l_pcPath = l_treeAnimatedModel.GetPszProperty("path",0);
const char* l_pcName = l_treeAnimatedModel.GetPszProperty("name",0);
if(l_pcPath == 0)
{
LOGGER->AddNewLog(ELL_WARNING, "CAnimatedModelManager::Load No s'ha trobat la propietat \"path\" a una animatedModel.");
} else if(l_pcName == 0)
{
LOGGER->AddNewLog(ELL_WARNING, "CAnimatedModelManager::Load No s'ha trobat la propietat \"name\" a una animatedModel.");
} else {
GetCore(l_pcName, l_pcPath);
}
} else if(!l_treeAnimatedModel.IsComment())
{
LOGGER->AddNewLog(ELL_WARNING, "CAnimatedModelManager::Load S'ha trobat un element desconegut \"%s\"", l_treeAnimatedModel.GetName());
}
}
} else {
LOGGER->AddNewLog(ELL_WARNING, "CAnimatedModelManager::Load No s'ha trobat el fitxer");
}
SetOk(true);
return IsOk();
}
bool CMultipleRenderTarget::Init(const string& _szName)
{
SetName(_szName);
SetOk(true);
return IsOk();
}
bool CComponentMirilla::Init(CGameEntity* _pEntity)
{
SetOk(true);
return IsOk();
}
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();
}
bool CPhysXProcess::Init()
{
LOGGER->AddNewLog(ELL_INFORMATION,"CPhysXProcess::Init");
CPhysicsManager* l_pPhysManager = CORE->GetPhysicsManager();
m_pObject = new CObject3D();
m_fVelocity = 2;
m_pObject->SetPosition(Vect3f(-6,1.7f,0));
m_pObjectBot = CORE->GetRenderableObjectsManager()->GetResource("bot");
m_iState = 0;
m_bStateChanged = false;
/*m_pObjectCamera = new CShoulderCamera(
0.1f,
100.0f,
55.0f * FLOAT_PI_VALUE/180.0f,
((float)RENDER_MANAGER->GetScreenWidth())/((float)RENDER_MANAGER->GetScreenHeight()),
m_pObject,
2.0f,0.6f,1.5f);*/
m_pObjectCamera = new CThPSCamera(
0.1f,
100.0f,
35.0f * FLOAT_PI_VALUE/180.0f,
((float)RENDER_MANAGER->GetScreenWidth())/((float)RENDER_MANAGER->GetScreenHeight()),
m_pObject,
4.5f);
m_pCamera = m_pObjectCamera;
((CThPSCamera*)m_pObjectCamera)->SetZoom(5.0f);
//m_pSceneEffectManager = CORE->GetSceneEffectManager();
//CSpotLight* l_Spot = (CSpotLight*)CORE->GetLightManager()->GetResource("Spot01");
/*m_pSpotlight = CORE->GetLightManager()->CreateSpotLight("FreeModeLight",
Vect3f(-2.15715f,0.0f,-7.32758f),
Vect3f(-5.4188f,0.0f,3.75613f),
CColor(Vect3f(1.0f,1.0f,1.0f)),
20.0f,
80.0f,
10.0f,
45.0f,
false );
m_pSpotlight->SetActive(false);*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////CODI PER MOSTRAR LES ESFERES ALS BONES
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//CRenderableAnimatedInstanceModel* l_pAnim = (CRenderableAnimatedInstanceModel*)CORE->GetRenderableObjectsManager()->GetResource("ariggle");
//CalCoreSkeleton* l_pSkeleton = l_pAnim->GetAnimatedInstanceModel()->GetAnimatedCoreModel()->GetCoreModel()->getCoreSkeleton();
//vector<CalCoreBone*> l_vBones = l_pSkeleton->getVectorCoreBone();
//CalVector l_vBonePos;
//for (size_t i=0;i<l_vBones.size();++i)
//{
// //l_vBones[0]->getBoundingData(plane,l_vBonePos);
// l_vBonePos = l_vBones[i]->getTranslationAbsolute();
// Vect3f l_vVector = Vect3f(l_vBonePos.x,l_vBonePos.y,l_vBonePos.z);
// SCollisionInfo l_cInfo;
// l_cInfo.m_CollisionPoint = l_vVector;
// l_cInfo.m_Normal = v3fZERO;
// g_vCollisions.push_back(l_cInfo);
//}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
g_pUserDataJoint1 = new CPhysicUserData("Objecte Joint 1");
g_pUserDataJoint2 = new CPhysicUserData("Objecte Joint 2");
g_pUserDataJoint3 = new CPhysicUserData("Objecte Joint 3");
g_pUserDataJoint1->SetPaint(true);
g_pUserDataJoint1->SetColor(colYELLOW);
g_pUserDataJoint2->SetPaint(true);
g_pUserDataJoint2->SetColor(colRED);
g_pUserDataJoint3->SetPaint(true);
g_pUserDataJoint3->SetColor(colGREEN);
g_pUserData = new CPhysicUserData("Plane");
g_pUserData->SetPaint(true);
g_pUserData->SetColor(colWHITE);
g_pJointActor1 = new CPhysicActor(g_pUserDataJoint1);
g_pJointActor2 = new CPhysicActor(g_pUserDataJoint2);
g_pJointActor3 = new CPhysicActor(g_pUserDataJoint3);
g_pJointActor1->AddBoxSphape(Vect3f(0.5f,0.5f,0.5f),v3fZERO,v3fZERO,NULL,GROUP_COLLIDABLE_PUSHABLE);
g_pJointActor2->AddSphereShape(0.4f,v3fZERO,v3fZERO,NULL,GROUP_COLLIDABLE_PUSHABLE);
g_pJointActor3->AddBoxSphape(Vect3f(0.3f,0.3f,0.3f),v3fZERO,v3fZERO,NULL,GROUP_COLLIDABLE_PUSHABLE);
g_pJointActor1->SetGlobalPosition(Vect3f(-9.0f,1.0f,-3.0f));
g_pJointActor2->SetGlobalPosition(Vect3f(-9.0f,3.0f,-3.0f));
g_pJointActor3->SetGlobalPosition(Vect3f(-9.0f,5.0f,-3.0f));
g_pJointActor1->CreateBody(1.0f);
g_pJointActor2->CreateBody(5.0f);
g_pJointActor3->CreateBody(10.0f);
g_pFixedJoint = new CPhysicFixedJoint();
g_pFixedJoint2 = new CPhysicFixedJoint();
g_pRevoluteJoint = new CPhysicRevoluteJoint();
g_pSphericalJoint = new CPhysicSphericalJoint();
g_pSphericalJoint2 = new CPhysicSphericalJoint();
//g_pSphericalJoint->GetPhXDescJoint()->
l_pPhysManager->AddPhysicActor(g_pJointActor1);
l_pPhysManager->AddPhysicActor(g_pJointActor2);
l_pPhysManager->AddPhysicActor(g_pJointActor3);
g_pJointActor3->GetPhXActor()->raiseBodyFlag(NX_BF_KINEMATIC);
g_pJointActor3->GetPhXActor()->setLinearDamping(0.5);
//g_pFixedJoint->SetInfo(g_pJointActor1,g_pJointActor2);
g_pSphericalJoint->SetInfoComplete(Vect3f(-9.0f,5.0f,-3.0f),Vect3f(0.0f,-1.0f,0.0f),g_pJointActor2,g_pJointActor3);
g_pSphericalJoint2->SetInfoComplete(Vect3f(-9.0f,3.0f,-3.0f),Vect3f(0.0f,-1.0f,0.0f),g_pJointActor1,g_pJointActor2);
//g_pSphericalJoint2->SetInfo(Vect3f(-9.0f,2.0f,-3.0f),g_pJointActor1,g_pJointActor2);
//g_pSphericalJoint->SetInfo(Vect3f(-9.0f,3.0f,-3.0f),g_pJointActor2,g_pJointActor3);
//g_pFixedJoint2->SetInfo(g_pJointActor2,g_pJointActor3);
//g_pRevoluteJoint->SetInfo(v3fZERO,Vect3f(0.1f,0.1f,0.1f),g_pJointActor1,g_pJointActor2);
//g_pSphericalJoint->SetInfo(Vect3f(-6.0f,2.0f,-3.0f),g_pJointActor2);
//g_pRevoluteJoint->SetMotor(1.0f,1.0f);
//g_pFixedJoint->CreateJoint(NULL);
//l_pPhysManager->AddPhysicFixedJoint(g_pFixedJoint);
//l_pPhysManager->AddPhysicFixedJoint(g_pFixedJoint2);
//l_pPhysManager->AddPhysicRevoluteJoint(g_pRevoluteJoint);
l_pPhysManager->AddPhysicSphericalJoint(g_pSphericalJoint);
l_pPhysManager->AddPhysicSphericalJoint(g_pSphericalJoint2);
g_pObjectManager = new CGameObjectManager();
g_pObjectManager->Load("Data/Levels/NivellProves/XML/GameObjects.xml",false);
//CPhysicActor* l_pLampada = g_pObjectManager->GetResource("Lampada")->GetPhysXActor();
//CPhysicActor* l_pCable = g_pObjectManager->GetResource("Cable_Lampada")->GetPhysXActor();
//Vect3f l_vMax = g_pObjectManager->GetResource("Cable_Lampada")->GetRenderableObject()->GetBoundingBox()->GetDimension();
//Vect3f l_vPos = g_pObjectManager->GetResource("Lampada")->GetRenderableObject()->GetPosition();
//Vect3f l_vPos2 = g_pObjectManager->GetResource("Cable_Lampada")->GetRenderableObject()->GetPosition();
//Vect3f l_vPos3 = l_vPos2;
//l_vPos2.y = l_vPos2.y - (l_vMax.y*0.5f);
//l_vPos3.y = l_vPos3.y + (l_vMax.y*0.5f);
//SCollisionInfo l_SInfo;
//l_SInfo.m_CollisionPoint = l_vPos2;
//l_SInfo.m_Normal = Vect3f(0.0f,-1.0f,0.0f);
//g_vCollisions.push_back(l_SInfo);
//l_SInfo.m_CollisionPoint = l_vPos3;
//g_vCollisions.push_back(l_SInfo);
//g_pSphericalJoint->SetInfo(l_vPos2,l_pLampada,l_pCable);
//g_pSphericalJoint2->SetInfo(l_vPos3,l_pCable);
//l_pPhysManager->AddPhysicSphericalJoint(g_pSphericalJoint);
//l_pPhysManager->AddPhysicSphericalJoint(g_pSphericalJoint2);
//CHARACTER CONTROLLER
g_pUserDataController = new CPhysicUserData("PhysX Controller");
g_pUserDataController->SetPaint(true);
g_pUserDataController->SetColor(colBLACK);
g_pPhysXController = new CPhysicController(RADIUS_CONTROLLER,ALTURA_CONTROLLER,10.0,0.05f,0.01f,COLISIONABLE_MASK,g_pUserDataController,Vect3f(-7.0f,2.2f,-4.0f));
g_pPhysXController->SetYaw(-90);
l_pPhysManager->AddPhysicController(g_pPhysXController);
m_pObject->SetPosition(g_pPhysXController->GetPosition());
//g_pObjectManager = new CGameObjectManager();
//g_pObjectManager->Load("Data/Levels/PhysX/XML/GameObjects.xml",false);
//Init del character de Riggle
g_pCharacter = (CRenderableAnimatedInstanceModel*)CORE->GetRenderableObjectsManager()->GetResource("ariggle");
if (g_pCharacter != 0)
{
Vect3f l_vPos = g_pPhysXController->GetPosition();
l_vPos.y = 0.0f;
g_pCharacter->SetPosition(l_vPos);
g_pCharacter->GetAnimatedInstanceModel()->BlendCycle("idle",0);
}
Vect3f l_ControllerPos = g_pPhysXController->GetPosition();
m_pObject->SetPosition(Vect3f(l_ControllerPos.x,l_ControllerPos.y,l_ControllerPos.z));
/*if(l_Spot)
{
l_Spot->SetDirection(l_ControllerPos);
l_Spot->SetActive(true);
}*/
m_bRenderLights = false;
CORE->GetLightManager()->SetLightsEnabled(true);
l_pPhysManager->SetDebugRenderMode(true);
/////////////////////////////////////////////////////////////////////////////////
//// RAGDOLL PROVES
/////////////////////////////////////////////////////////////////////////////////
//CRenderableAnimatedInstanceModel* l_pAnim = (CRenderableAnimatedInstanceModel*)CORE->GetRenderableObjectsManager()->GetResource("rigglebot");
//CalSkeleton* l_pSkeleton = l_pAnim->GetAnimatedInstanceModel()->GetAnimatedCalModel()->getSkeleton();
//l_pSkeleton->getCoreSkeleton()->calculateBoundingBoxes(l_pAnim->GetAnimatedInstanceModel()->GetAnimatedCalModel()->getCoreModel());
//l_pSkeleton->calculateBoundingBoxes();
//if (g_pRagdoll == 0)
//{
// g_pRagdoll = new CPhysxSkeleton();
// CalModel* l_pCalModel = l_pAnim->GetAnimatedInstanceModel()->GetAnimatedCalModel();
// g_pRagdoll->Init("Data/Animated Models/Riggle/Skeleton.xml",l_pCalModel,l_pAnim->GetMat44());
//}
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
CORE->GetRenderableObjectsManager()->AddMeshInstance("laser_pilota", "Mirilla");
SetOk(true);
return IsOk();
}
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();
}
bool CEmiterInstance::Init(const string& _szCoreName, const CObject3D& _Position, const Vect3f& _vVolume, int _iMaxParticles, bool _bBillboardMode )
{
assert(!IsOk());
SetOk(true);
SetMat44( _Position.GetMat44() );
m_szCoreName = _szCoreName;
m_vVolume = _vVolume;
m_vMaxVolume = m_vVolume * .5f;
m_vMinVolume = -m_vMaxVolume;
m_fVolume = _vVolume.x * _vVolume.y * _vVolume.z;
m_pEmiterCore = CORE->GetEmiterCoreManager()->GetEmiterCore(m_szCoreName);
m_bBillboardMode = _bBillboardMode;
m_iMaxParticles = _iMaxParticles;
m_RecyclingParticles.Reset(m_iMaxParticles);
m_iaParticles = new int[m_iMaxParticles];
GetBoundingBox()->Init(_vVolume);
if(m_bBillboardMode)
{
if(m_pEmiterCore->IsSimpleEmiter())
{
m_Billboard.Init(dynamic_cast<const CSimpleEmiterCore*>(m_pEmiterCore), Vect3f(0,0,0),true);
}
else
{
LOGGER->AddNewLog(ELL_WARNING, "Trying to initialize billboard with aggregate emiter.");
m_pEmiterCore = CORE->GetEmiterCoreManager()->GetNullEmiter();
m_Billboard.Init(CORE->GetEmiterCoreManager()->GetNullEmiter(), Vect3f(0,0,0),true);
}
} else if(m_pEmiterCore->IsSimpleEmiter())
{
m_bIsSimple = true;
const CSimpleEmiterCore *l_pEmiterCore = dynamic_cast<const CSimpleEmiterCore*>(m_pEmiterCore);
float l_fMultiplier = l_pEmiterCore->GetEmitAbsolute()? 1 : m_fVolume;
m_fTimeToNextParticle = 1.f / (l_pEmiterCore->GetEmitRate() * l_fMultiplier);
m_iActiveParticles = 0;
memset(m_iaParticles, 0, sizeof(int) * m_iMaxParticles);
m_bAwake = true;
m_fTimeToAwakeOrSleep = l_pEmiterCore->GetAwakeTime();
m_pObjectReference = 0;
m_bActive = true;
}
else
{
m_bIsSimple = false;
const CAggregateEmiterCore *l_pEmiterCore = dynamic_cast<const CAggregateEmiterCore*>(m_pEmiterCore);
vector<CAggregateEmiterCore::SEmiters>::const_iterator l_it = l_pEmiterCore->GetChilds().begin();
vector<CAggregateEmiterCore::SEmiters>::const_iterator l_end = l_pEmiterCore->GetChilds().end();
for(; l_it != l_end; ++l_it)
{
CEmiterInstance *l_pChild = new CEmiterInstance();
Vect3f l_vChildBox = l_it->volume.GetScaled(_vVolume);
//Mat44f l_mChildTransform = Mat44f(_vVolume.x, 0, 0, 0,
// 0, _vVolume.y, 0, 0,
// 0, 0, _vVolume.z, 0,
// 0, 0, 0, 1)
// * l_it->movement.GetMat44();
//CObject3D l_O3D;
//l_O3D.SetMat44(l_mChildTransform);
Mat44f l_mChildTransform = l_it->movement.GetMat44();
Vect3f l_vChildTranslation = l_mChildTransform.GetTranslationVector();
l_vChildTranslation.Scale(_vVolume);
l_mChildTransform.Translate(l_vChildTranslation);
CObject3D l_O3D;
l_O3D.SetMat44(l_mChildTransform);
bool l_bIsOk = l_pChild->Init(l_it->emiter, l_O3D, l_vChildBox);
if(l_bIsOk)
{
m_ChildEmiters.push_back(l_pChild);
GetBoundingBox()->Adjust(*l_pChild->GetBoundingBox());
}
else
{
delete l_pChild;
SetOk(false);
break;
}
}
}
if(!IsOk())
{
Release();
}
else if(!m_InstancedData.IsOk())
{
bool l_bIsOk = m_InstancedData.Init(CORE->GetRenderManager(), m_iMaxParticles);
SetOk(l_bIsOk);
}
GetBoundingSphere()->Init(*GetBoundingBox());
if(IsOk())
CORE->GetPortalManager()->InsertEmiter(this);
return IsOk();
}
bool CComponentPhysXSphere::Init(CGameEntity *_pEntity, float _fDensity, float _fRadius, float _fSkeletonSize, int _iCollisionGroup)
{
m_fDensity = _fDensity;
m_iCollisionGroup = _iCollisionGroup;
m_fRadius = _fRadius;
m_fSkeletonSize = _fSkeletonSize;
m_pObject3D = _pEntity->GetComponent<CComponentObject3D>(ECT_OBJECT_3D);
if(!m_pObject3D)
{
LOGGER->AddNewLog(ELL_WARNING,"CComponentPhysXSphere::Init L'objecte no té el component CComponentObject3D.");
return false;
}
CComponentRenderableObject* l_pComponentRenderableObject = _pEntity->GetComponent<CComponentRenderableObject>(ECT_RENDERABLE_OBJECT);
if(!l_pComponentRenderableObject)
{
LOGGER->AddNewLog(ELL_WARNING,"CComponentPhysXSphere::Init L'objecte no té el component CComponentRenderableObject.");
return false;
}
CRenderableObject* l_pRenderableObject = l_pComponentRenderableObject->GetRenderableObject();
CBoundingBox* l_pBB = l_pRenderableObject->GetBoundingBox();
CBoundingSphere* l_pBS = l_pRenderableObject->GetBoundingSphere();
m_pPhysXData = new CPhysicUserData(_pEntity->GetName().c_str());
m_pPhysXData->SetPaint(true);
m_pPhysXData->SetColor(colBLUE);
m_pPhysXData->SetEntity(_pEntity);
m_pPhysXActor = new CPhysicActor(m_pPhysXData);
if (_fSkeletonSize > 0)
{
m_pPhysXActor->AddSphereShape(_fRadius,m_pObject3D->GetPosition(), v3fZERO, CORE->GetPhysicsManager()->CreateCCDSkeleton(_fSkeletonSize), _iCollisionGroup);
}
else
{
m_pPhysXActor->AddSphereShape(_fRadius,m_pObject3D->GetPosition(), v3fZERO, NULL, _iCollisionGroup);
}
//m_pPhysXActor->SetGlobalPosition(m_pObject3D->GetPosition());
if(_fDensity > 0)
{
m_pPhysXActor->CreateBody(_fDensity);
}else{
m_pPhysXActor->CreateBody(100.0f);
}
//m_pPhysXActor->CreateBody(1);
CORE->GetPhysicsManager()->AddPhysicActor(m_pPhysXActor);
/*if(_fDensity == 0)
{
m_pPhysXActor->SetKinematic(true);
}*/
/*Mat44f l_vMat = m_pObject3D->GetMat44();
m_pPhysXActor->SetMat44(l_vMat);*/
SetOk(true);
return IsOk();
}
