//------------------------------------------------------------------------
void CGameRulesHoldObjectiveBase::UpdateEffect(float frameTime)
{
IEntity *pRingEntity = gEnv->pEntitySystem->GetEntity(m_effectData.ringEntityID);
if(pRingEntity)
{
// Update lerps
m_effectData.materialColorLerp.UpdateLerp(frameTime);
m_effectData.particleColorLerp.UpdateLerp(frameTime);
// Update ring cgf
if(m_effectData.alphaLerp.HasFinishedLerping() == false)
{
if(m_effectData.alphaFadeInDelay > 0.0f)
{
m_effectData.alphaFadeInDelay -= frameTime;
if(m_effectData.alphaFadeInDelay <= 0.0f)
{
m_effectData.alphaFadeInDelay = 0.0f;
float alpha = min(m_effectData.alphaLerp.GetValue(),0.99f);
SetRingAlpha(pRingEntity,alpha);
pRingEntity->Hide(false);
}
}
else
{
m_effectData.alphaLerp.UpdateLerp(frameTime);
float alpha = min(m_effectData.alphaLerp.GetValue(),0.99f);
SetRingAlpha(pRingEntity,alpha);
// Fully faded out, so hide
if(m_effectData.alphaLerp.HasFinishedLerping() && m_effectData.alphaLerp.GetNewValue() == 0.0f)
{
pRingEntity->Hide(true);
SetNewEffectColor(eRPT_Neutral);
}
}
}
// Update Color
float lerpValue = m_effectData.materialColorLerp.GetValue();
Vec3 currentColor = LERP(*m_effectData.pPrevCol,*m_effectData.pDestCol,lerpValue);
// Set ring color
IEntityRenderProxy* pRenderProxy = (IEntityRenderProxy*)pRingEntity->GetProxy(ENTITY_PROXY_RENDER);
if(pRenderProxy)
{
IMaterial* pRingMaterial = pRenderProxy->GetRenderMaterial();
SetMaterialDiffuseColor(pRingMaterial,currentColor);
}
// Set particle geom material color
SetMaterialDiffuseColor(m_effectData.pParticleGeomMaterial,currentColor);
}
}
//------------------------------------------------------------------------
void CGameRulesHoldObjectiveBase::SetRingAlpha(IEntity* pRingEntity,float alpha)
{
if(pRingEntity)
{
IEntityRenderProxy* pRenderProxy = (IEntityRenderProxy*)pRingEntity->GetProxy(ENTITY_PROXY_RENDER);
if(pRenderProxy)
{
IMaterial* pRindMaterial = pRenderProxy->GetRenderMaterial();
SetMaterialDiffuseAlpha(pRindMaterial,alpha);
}
}
}
void CDoorPanel::AssignAsFSCommandHandler()
{
IEntity* pEntity = GetEntity();
if (pEntity)
{
IEntityRenderProxy* pRenderProxy = static_cast<IEntityRenderProxy*>(pEntity->GetProxy(ENTITY_PROXY_RENDER));
if (pRenderProxy)
{
_smart_ptr<IMaterial> pMaterial = pRenderProxy->GetRenderMaterial(DOOR_PANEL_MODEL_NORMAL_SLOT);
IFlashPlayer* pFlashPlayer = CHUDUtils::GetFlashPlayerFromMaterialIncludingSubMaterials(pMaterial, true);
if (pFlashPlayer) // Valid to not have a flash player, since will update when flash setup
{
pFlashPlayer->SetFSCommandHandler(this);
pFlashPlayer->Release();
}
}
}
}
IMaterial* CDoorPanelBehavior::CreateClonedMaterial( IEntity* pEntity, const int iSlotIndex )
{
CRY_ASSERT( m_pClonedAnimatedMaterial == NULL );
IMaterial* pClonedMaterial = NULL;
IEntityRenderProxy* pRenderProxy = static_cast<IEntityRenderProxy*>(pEntity->GetProxy(ENTITY_PROXY_RENDER));
if (pRenderProxy)
{
IMaterial* pOriginalMaterial = pRenderProxy->GetRenderMaterial(iSlotIndex);
if (pOriginalMaterial)
{
IMaterialManager* pMatManager = gEnv->p3DEngine->GetMaterialManager();
CRY_ASSERT(pMatManager);
pClonedMaterial = pMatManager->CloneMaterial( pOriginalMaterial );
if (pClonedMaterial)
{
m_pClonedAnimatedMaterial = pClonedMaterial;
pClonedMaterial->SetFlags( pClonedMaterial->GetFlags()|MTL_FLAG_PURE_CHILD ); // Notify that its not shared so won't try to remove by name in material manager which removes original material
}
else
{
GameWarning("CDoorPanelBehavior::CreateClonedMaterial: Failed to clone material");
}
}
else
{
GameWarning("CDoorPanelBehavior::CreateClonedMaterial: Failed to get material from slot: %d", DOOR_PANEL_MODEL_NORMAL_SLOT);
}
}
else
{
GameWarning("CDoorPanelBehavior::CreateClonedMaterial: Failed getting render proxy");
}
return pClonedMaterial;
}
void CDoorPanelBehavior::DeinitFlashResources( CDoorPanel& doorPanel )
{
if (m_pFlashObjectRoot)
{
SAFE_RELEASE(m_pFlashObjectRoot);
if (doorPanel.m_sharingMaterialEntity == 0)
{
IEntity* pEntity = doorPanel.GetEntity();
IEntityRenderProxy* pRenderProxy = static_cast<IEntityRenderProxy*>(pEntity->GetProxy(ENTITY_PROXY_RENDER));
if (pRenderProxy)
{
IMaterial* pMaterial = pRenderProxy->GetRenderMaterial(DOOR_PANEL_MODEL_NORMAL_SLOT);
if (pMaterial)
{
IFlashPlayer* pFlashPlayer = CHUDUtils::GetFlashPlayerFromMaterialIncludingSubMaterials(pMaterial, true);
if (pFlashPlayer)
{
pFlashPlayer->SetFSCommandHandler(NULL);
pFlashPlayer->Release();
}
CDoorPanelBehavior::DecrementNumUniqueFlashInstances(pMaterial->GetName());
doorPanel.NotifyScreenSharingEvent(eDoorPanelGameObjectEvent_StopShareScreen);
}
}
if (m_pActualAnimatedMaterial)
{
m_pActualAnimatedMaterial->ActivateDynamicTextureSources(false);
}
}
}
}
//------------------------------------------------------------------------
bool CVehiclePartTread::Init(IVehicle* pVehicle, const CVehicleParams& table, IVehiclePart* parent, CVehicle::SPartInitInfo& initInfo, int partType)
{
if (!CVehiclePartBase::Init(pVehicle, table, parent, initInfo, eVPT_Tread))
return false;
CVehicleParams subTable = table.findChild("Tread"); // Tread subtable
if (!subTable)
return false;
string filename = subTable.getAttr("filename");
if (filename.empty())
return false;
subTable.getAttr("uvSpeedMultiplier", m_uvSpeedMultiplier);
if (table.haveAttr("component"))
{
if (CVehicleComponent* pComponent = static_cast<CVehicleComponent*>(m_pVehicle->GetComponent(table.getAttr("component"))))
pComponent->AddPart(this);
}
m_slot = GetEntity()->LoadCharacter(m_slot, filename);
m_pCharInstance = GetEntity()->GetCharacter(m_slot);
if (!m_pCharInstance)
return false;
if (subTable.haveAttr("materialName"))
{
string materialName = subTable.getAttr("materialName");
materialName.MakeLower();
IMaterial* pMaterial = 0;
const char* subMtlName = 0;
int subMtlSlot = -1;
// find tread material
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy*)GetEntity()->GetProxy(ENTITY_PROXY_RENDER);
if (pRenderProxy)
{
pMaterial = pRenderProxy->GetRenderMaterial(m_slot);
if (pMaterial)
{
// if matname doesn't fit, look in submaterials
if (string(pMaterial->GetName()).MakeLower().find(materialName) == string::npos)
{
for (int i=0; i < pMaterial->GetSubMtlCount(); ++i)
{
if (string(pMaterial->GetSubMtl(i)->GetName()).MakeLower().find(materialName) != string::npos)
{
subMtlName = pMaterial->GetSubMtl(i)->GetName();
subMtlSlot = i;
break;
}
}
}
}
}
if (pMaterial)
{
// clone
IMaterial *pCloned = pMaterial->GetMaterialManager()->CloneMultiMaterial(pMaterial, subMtlName);
if (pCloned)
{
pRenderProxy->SetSlotMaterial(m_slot, pCloned);
pMaterial = pCloned;
m_pMaterial = pMaterial;
}
if (subMtlSlot > -1)
m_pShaderResources = pMaterial->GetShaderItem(subMtlSlot).m_pShaderResources;
else
m_pShaderResources = pMaterial->GetShaderItem().m_pShaderResources;
}
if (m_pShaderResources)
{
for (int i = 0; i < EFTT_MAX; ++i)
{
if (!m_pShaderResources->GetTexture(i))
continue;
SEfTexModificator& modif = *m_pShaderResources->GetTexture(i)->AddModificator();
modif.SetMember("m_eMoveType[0]", 1.0f); // ETMM_Fixed: u = m_OscRate[0] + sourceU
modif.SetMember("m_OscRate[0]", 0.0f);
}
}
}
char wheelName[256];
IDefaultSkeleton& rIDefaultSkeleton = m_pCharInstance->GetIDefaultSkeleton();
for (int i=0; i<rIDefaultSkeleton.GetJointCount(); ++i)
{
const char* boneName = rIDefaultSkeleton.GetJointNameByID(i);
if (0 != boneName)
{
// extract wheel name
const size_t len = strcspn(boneName, "_");
if (len < strlen(boneName) && len < sizeof(wheelName))
{
cry_strcpy(wheelName, boneName, len);
CVehiclePartSubPartWheel* pWheel = (CVehiclePartSubPartWheel*)m_pVehicle->GetPart(wheelName);
if (pWheel)
{
SWheelInfo wheelInfo;
wheelInfo.slot = pWheel->m_slot;
wheelInfo.jointId = i;
wheelInfo.pWheel = pWheel;
m_wheels.push_back(wheelInfo);
m_lastWheelIndex = pWheel->GetWheelIndex();
}
}
}
}
m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
m_state = eVGS_Default;
return true;
}
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
switch (event)
{
case eFE_Initialize:
break;
case eFE_Activate:
IGameFramework* pGameFramework = gEnv->pGame->GetIGameFramework();
if(IsPortActive(pActInfo, EIP_Cast))
{
// setup ray + optionally skip 1 entity
ray_hit rayHit;
static const float maxRayDist = 100.f;
const unsigned int flags = rwi_stop_at_pierceable|rwi_colltype_any;
IPhysicalEntity *skipList[1];
int skipCount = 0;
IEntity* skipEntity = gEnv->pEntitySystem->GetEntity(GetPortEntityId(pActInfo, EIP_SkipEntity));
if(skipEntity)
{
skipList[0] = skipEntity->GetPhysics();
skipCount = 1;
}
Vec3 rayPos = GetPortVec3(pActInfo, EIP_RayPos);
Vec3 rayDir = GetPortVec3(pActInfo, EIP_RayDir);
// Check if the ray hits an entity
if(gEnv->pSystem->GetIPhysicalWorld()->RayWorldIntersection(rayPos, rayDir * 100, ent_all, flags, &rayHit, 1, skipList, skipCount))
{
int type = rayHit.pCollider->GetiForeignData();
if (type == PHYS_FOREIGN_ID_ENTITY)
{
IEntity* pEntity = (IEntity*)rayHit.pCollider->GetForeignData(PHYS_FOREIGN_ID_ENTITY);
IEntityRenderProxy* pRenderProxy = pEntity ? (IEntityRenderProxy*)pEntity->GetProxy(ENTITY_PROXY_RENDER) : 0;
// Get the renderproxy, and use it to check if the material is a DynTex, and get the UIElement if so
if(pRenderProxy)
{
IRenderNode *pRenderNode = pRenderProxy->GetRenderNode();
IMaterial* pMaterial = pRenderProxy->GetRenderMaterial();
SEfResTexture* texture = 0;
if(pMaterial && pMaterial->GetShaderItem().m_pShaderResources)
texture= pMaterial->GetShaderItem().m_pShaderResources->GetTexture(EFTT_DIFFUSE);
IUIElement* pElement = texture ? gEnv->pFlashUI->GetUIElementByInstanceStr(texture->m_Name) : 0;
if(pElement && pRenderNode)
{
int m_dynTexGeomSlot = 0;
IStatObj* pObj = pRenderNode->GetEntityStatObj(m_dynTexGeomSlot);
// result
bool hasHit = false;
Vec2 uv0, uv1, uv2;
Vec3 p0, p1, p2;
Vec3 hitpos;
// calculate ray dir
CCamera cam = gEnv->pRenderer->GetCamera();
if (pEntity->GetSlotFlags(m_dynTexGeomSlot) & ENTITY_SLOT_RENDER_NEAREST)
{
ICVar *r_drawnearfov = gEnv->pConsole->GetCVar("r_DrawNearFoV");
assert(r_drawnearfov);
cam.SetFrustum(cam.GetViewSurfaceX(),cam.GetViewSurfaceZ(),DEG2RAD(r_drawnearfov->GetFVal()),cam.GetNearPlane(),cam.GetFarPlane(), cam.GetPixelAspectRatio());
}
Vec3 vPos0 = rayPos;
Vec3 vPos1 = rayPos + rayDir;
// translate into object space
const Matrix34 m = pEntity->GetWorldTM().GetInverted();
vPos0 = m * vPos0;
vPos1 = m * vPos1;
// walk through all sub objects
const int objCount = pObj->GetSubObjectCount();
for (int obj = 0; obj <= objCount && !hasHit; ++obj)
{
Vec3 vP0, vP1;
IStatObj* pSubObj = NULL;
if (obj == objCount)
{
vP0 = vPos0;
vP1 = vPos1;
pSubObj = pObj;
}
else
{
IStatObj::SSubObject* pSub = pObj->GetSubObject(obj);
const Matrix34 mm = pSub->tm.GetInverted();
vP0 = mm * vPos0;
vP1 = mm * vPos1;
pSubObj = pSub->pStatObj;
}
IRenderMesh* pMesh = pSubObj ? pSubObj->GetRenderMesh() : NULL;
if (pMesh)
{
const Ray ray(vP0, (vP1-vP0).GetNormalized() * maxRayDist);
hasHit = RayIntersectMesh(pMesh, pMaterial, pElement, ray, hitpos, p0, p1, p2, uv0, uv1, uv2);
}
}
// skip if not hit
if (!hasHit)
{
ActivateOutput(pActInfo, EOP_Failed, 1);
return;
}
// calculate vectors from hitpos to vertices p0, p1 and p2:
const Vec3 v0 = p0-hitpos;
const Vec3 v1 = p1-hitpos;
const Vec3 v2 = p2-hitpos;
// calculate factors
const float h = (p0-p1).Cross(p0-p2).GetLength();
const float f0 = v1.Cross(v2).GetLength() / h;
const float f1 = v2.Cross(v0).GetLength() / h;
const float f2 = v0.Cross(v1).GetLength() / h;
// find the uv corresponding to hitpos
Vec3 uv = uv0 * f0 + uv1 * f1 + uv2 * f2;
// translate to flash space
int x, y, width, height;
float aspect;
pElement->GetFlashPlayer()->GetViewport(x, y, width, height, aspect);
int iX = int_round(uv.x * (float)width);
int iY = int_round(uv.y * (float)height);
// call the function provided if it is present in the UIElement description
string funcName = GetPortString(pActInfo, EIP_CallFunction);
const SUIEventDesc* eventDesc = pElement->GetFunctionDesc(funcName);
if(eventDesc)
{
SUIArguments arg;
arg.AddArgument(iX);
arg.AddArgument(iY);
pElement->CallFunction(eventDesc->sName, arg);
}
ActivateOutput(pActInfo, EOP_Success, 1);
}
}
}
}
ActivateOutput(pActInfo, EOP_Failed, 1);
}
break;
}
}