//проверка на попадание "осколком" по объекту
ICF static BOOL grenade_hit_callback(collide::rq_result& result, LPVOID params)
{
SExpQParams& ep = *(SExpQParams*)params;
u16 mtl_idx = GAMEMTL_NONE_IDX;
if(result.O){
CKinematics* V = 0;
if (0!=(V=smart_cast<CKinematics*>(result.O->Visual()))){
CBoneData& B= V->LL_GetData((u16)result.element);
mtl_idx = B.game_mtl_idx;
}
}else{
//получить треугольник и узнать его материал
CDB::TRI* T = Level().ObjectSpace.GetStaticTris()+result.element;
mtl_idx = T->material;
}
SGameMtl* mtl = GMLib.GetMaterialByIdx(mtl_idx);
ep.shoot_factor *=mtl->fShootFactor;
#ifdef DEBUG
if(ph_dbg_draw_mask.test(phDbgDrawExplosions))
{
Fvector p;p.set(ep.l_dir);p.mul(result.range);p.add(ep.source_p);
u8 c =u8(mtl->fShootFactor*255.f);
DBG_DrawPoint(p,0.1f,D3DCOLOR_XRGB(255-c,0,c));
}
#endif
return (ep.shoot_factor>0.01f);
}
void CModelPool::dump()
{
Log ("--- model pool --- begin:");
u32 sz = 0;
u32 k = 0;
for (xr_vector<ModelDef>::iterator I=Models.begin(); I!=Models.end(); I++) {
CKinematics* K = PCKinematics(I->model);
if (K){
u32 cur = K->mem_usage (false);
sz += cur;
Msg("#%3d: [%3d/%5d Kb] - %s",k++,I->refs,cur/1024,I->name.c_str());
}
}
Msg ("--- models: %d, mem usage: %d Kb ",k,sz/1024);
sz = 0;
k = 0;
int free_cnt = 0;
for (REGISTRY_IT it=Registry.begin(); it!=Registry.end(); it++)
{
CKinematics* K = PCKinematics((dxRender_Visual*)it->first);
VERIFY (K);
if (K){
u32 cur = K->mem_usage (true);
sz += cur;
bool b_free = (Pool.find(it->second)!=Pool.end() );
if(b_free) ++free_cnt;
Msg("#%3d: [%s] [%5d Kb] - %s",k++, (b_free)?"free":"used", cur/1024,it->second.c_str());
}
}
Msg ("--- instances: %d, free %d, mem usage: %d Kb ",k, free_cnt, sz/1024);
Log ("--- model pool --- end.");
}
void CDamageManager::load_section(LPCSTR section,CInifile* ini)
{
string32 buffer;
CKinematics *kinematics = smart_cast<CKinematics*>(m_object->Visual());
CInifile::Sect &damages = ini->r_section(section);
for (CInifile::SectCIt i=damages.Data.begin(); damages.Data.end() != i; ++i) {
if (xr_strcmp(*(*i).first,"default")) { // read all except default line
VERIFY (m_object);
int bone = kinematics->LL_BoneID(i->first);
R_ASSERT2 (BI_NONE != bone, *(*i).first);
CBoneInstance &bone_instance = kinematics->LL_GetBoneInstance(u16(bone));
bone_instance.set_param (0,(float)atof(_GetItem(*(*i).second,0,buffer)));
bone_instance.set_param (1,(float)atoi(_GetItem(*(*i).second,1,buffer)));
bone_instance.set_param (2,(float)atof(_GetItem(*(*i).second,2,buffer)));
if (_GetItemCount(*(*i).second) < 4)
{
bone_instance.set_param (3,(float)atof(_GetItem(*(*i).second,0,buffer)));
}
else
{
bone_instance.set_param (3,(float)atof(_GetItem(*(*i).second,3,buffer)));
}
if(0==bone && (fis_zero(bone_instance.get_param(0)) || fis_zero(bone_instance.get_param(2)) ) ){
string256 error_str;
sprintf_s(error_str,"hit_scale and wound_scale for root bone cannot be zero. see section [%s]",section);
R_ASSERT2(0,error_str);
}
}
}
}
void CDamageManager::HitScale (const int element, float& hit_scale, float& wound_scale, bool aim_bullet)
{
if(BI_NONE == u16(element))
{
//считаем что параметры для BI_NONE заданы как 1.f
hit_scale = 1.f * m_default_hit_factor;
wound_scale = 1.f * m_default_wound_factor;
return;
}
CKinematics* V = smart_cast<CKinematics*>(m_object->Visual()); VERIFY(V);
// get hit scale
float scale;
if (aim_bullet)
{
scale = V->LL_GetBoneInstance(u16(element)).get_param(3);
}
else
{
scale = V->LL_GetBoneInstance(u16(element)).get_param(0);
}
hit_scale = scale;
// get wound scale
scale = V->LL_GetBoneInstance(u16(element)).get_param(2);
wound_scale = scale;
}
virtual void Execute(LPCSTR arguments)
{
if (!arguments || !*arguments) {
Msg ("! no arguments passed");
return;
}
string_path name;
string_path fn;
if (0==strext(arguments))
strconcat (sizeof(name),name,arguments,".ogf");
else
strcpy_s (name,sizeof(name),arguments);
if (!FS.exist(arguments) && !FS.exist(fn, "$level$", name) && !FS.exist(fn, "$game_meshes$", name)) {
Msg ("! Cannot find visual \"%s\"",arguments);
return;
}
IRender_Visual *visual = Render->model_Create(arguments);
CKinematics *kinematics = smart_cast<CKinematics*>(visual);
if (!kinematics) {
Render->model_Delete(visual);
Msg ("! Invalid visual type \"%s\" (not a CKinematics)",arguments);
return;
}
Msg ("bones for model \"%s\"",arguments);
for (u16 i=0, n=kinematics->LL_BoneCount(); i<n; ++i)
Msg ("%s",*kinematics->LL_GetData(i).name);
Render->model_Delete (visual);
}
void CObjectHandler::weapon_bones (int &b0, int &b1, int &b2) const
{
CWeapon *weapon = smart_cast<CWeapon*>(inventory().ActiveItem());
if (!weapon || !planner().m_storage.property(ObjectHandlerSpace::eWorldPropertyStrapped)) {
if (weapon)
weapon->strapped_mode (false);
b0 = m_r_hand;
b1 = m_r_finger2;
b2 = m_l_finger1;
return;
}
THROW3 (weapon->can_be_strapped(),"Cannot strap weapon",*weapon->cName());
if (weapon->ID() != m_strap_object_id) {
CKinematics *kinematics = smart_cast<CKinematics*>(planner().m_object->Visual());
m_strap_bone0 = kinematics->LL_BoneID(weapon->strap_bone0());
m_strap_bone1 = kinematics->LL_BoneID(weapon->strap_bone1());
m_strap_object_id = weapon->ID();
}
weapon->strapped_mode (true);
b0 = m_strap_bone0;
b1 = m_strap_bone1;
b2 = b1;
}
void CAI_Trader::g_WeaponBones (int &L, int &R1, int &R2)
{
CKinematics *V = smart_cast<CKinematics*>(Visual());
R1 = V->LL_BoneID("bip01_r_hand");
R2 = V->LL_BoneID("bip01_r_finger2");
L = V->LL_BoneID("bip01_l_finger1");
}
void CPhysicsShellHolder::PHSaveState(NET_Packet &P)
{
//CPhysicsShell* pPhysicsShell=PPhysicsShell();
CKinematics* K =smart_cast<CKinematics*>(Visual());
//Flags8 lflags;
//if(pPhysicsShell&&pPhysicsShell->isActive()) lflags.set(CSE_PHSkeleton::flActive,pPhysicsShell->isEnabled());
// P.w_u8 (lflags.get());
if(K)
{
P.w_u64(K->LL_GetBonesVisible());
P.w_u16(K->LL_GetBoneRoot());
}
else
{
P.w_u64(u64(-1));
P.w_u16(0);
}
/////////////////////////////
Fvector min,max;
min.set(flt_max,flt_max,flt_max);
max.set(-flt_max,-flt_max,-flt_max);
/////////////////////////////////////
u16 bones_number=PHGetSyncItemsNumber();
for(u16 i=0;i<bones_number;i++)
{
SPHNetState state;
PHGetSyncItem(i)->get_State(state);
Fvector& p=state.position;
if(p.x<min.x)min.x=p.x;
if(p.y<min.y)min.y=p.y;
if(p.z<min.z)min.z=p.z;
if(p.x>max.x)max.x=p.x;
if(p.y>max.y)max.y=p.y;
if(p.z>max.z)max.z=p.z;
}
min.sub(2.f*EPS_L);
max.add(2.f*EPS_L);
VERIFY(!min.similar(max));
P.w_vec3(min);
P.w_vec3(max);
P.w_u16(bones_number);
for(u16 i=0;i<bones_number;i++)
{
SPHNetState state;
PHGetSyncItem(i)->get_State(state);
state.net_Save(P,min,max);
}
}
void CCarWeapon::UpdateCL()
{
if(!m_bActive) return;
UpdateBarrelDir ();
CKinematics* K = smart_cast<CKinematics*>(m_object->Visual());
K->CalculateBones_Invalidate();
K->CalculateBones ();
UpdateFire ();
}
void CHangingLamp::RespawnInit()
{
Init();
if(Visual()){
CKinematics* K = smart_cast<CKinematics*>(Visual());
K->LL_SetBonesVisible(u64(-1));
K->CalculateBones_Invalidate();
K->CalculateBones ();
}
}
void CInventoryItem::UpdateXForm ()
{
if (0==object().H_Parent()) return;
// Get access to entity and its visual
CEntityAlive* E = smart_cast<CEntityAlive*>(object().H_Parent());
if (!E) return;
if (E->cast_base_monster()) return;
const CInventoryOwner *parent = smart_cast<const CInventoryOwner*>(E);
if (parent && parent->use_simplified_visual())
return;
if (parent->attached(this))
return;
R_ASSERT (E);
CKinematics* V = smart_cast<CKinematics*> (E->Visual());
VERIFY (V);
// Get matrices
int boneL,boneR,boneR2;
E->g_WeaponBones(boneL,boneR,boneR2);
// if ((HandDependence() == hd1Hand) || (STATE == eReload) || (!E->g_Alive()))
// boneL = boneR2;
#pragma todo("TO ALL: serious performance problem")
V->CalculateBones ();
Fmatrix& mL = V->LL_GetTransform(u16(boneL));
Fmatrix& mR = V->LL_GetTransform(u16(boneR));
// Calculate
Fmatrix mRes;
Fvector R,D,N;
D.sub (mL.c,mR.c); D.normalize_safe();
if(fis_zero(D.magnitude()))
{
mRes.set(E->XFORM());
mRes.c.set(mR.c);
}
else
{
D.normalize();
R.crossproduct (mR.j,D);
N.crossproduct (D,R);
N.normalize();
mRes.set (R,N,D,mR.c);
mRes.mulA_43 (E->XFORM());
}
// UpdatePosition (mRes);
object().Position().set(mRes.c);
}
void CParticlesPlayer::GetBonePos (CObject* pObject, u16 bone_id, const Fvector& offset, Fvector& result)
{
VERIFY(pObject);
CKinematics* pKinematics = smart_cast<CKinematics*>(pObject->Visual());
VERIFY(pKinematics);
CBoneInstance& l_tBoneInstance = pKinematics->LL_GetBoneInstance(bone_id);
result = offset;
l_tBoneInstance.mTransform.transform_tiny(result);
pObject->XFORM().transform_tiny(result);
}
void CDamageManager::init_bones(LPCSTR section,CInifile* ini)
{
CKinematics *kinematics = smart_cast<CKinematics*>(m_object->Visual());
VERIFY (kinematics);
for(u16 i = 0; i<kinematics->LL_BoneCount(); i++)
{
CBoneInstance &bone_instance = kinematics->LL_GetBoneInstance(i);
bone_instance.set_param (0,m_default_hit_factor);
bone_instance.set_param (1,1.f);
bone_instance.set_param (2,m_default_wound_factor);
}
}
void CCar::SWheelBreak::Load(LPCSTR section)
{
CKinematics *K =PKinematics(pwheel->car->Visual()) ;
CInifile *ini =K->LL_UserData() ;
VERIFY (ini) ;
break_torque = ini->r_float("car_definition","break_torque") ;
hand_break_torque = READ_IF_EXISTS(ini,r_float,"car_definition","hand_break_torque",break_torque) ;
if(ini->section_exist(section))
{
break_torque =READ_IF_EXISTS(ini,r_float,section,"break_torque",break_torque);
hand_break_torque =READ_IF_EXISTS(ini,r_float,section,"hand_break_torque",hand_break_torque);
}
}
void CHangingLamp::TurnOn ()
{
light_render->set_active (true);
if (glow_render) glow_render->set_active (true);
if (light_ambient) light_ambient->set_active (true);
if (Visual()){
CKinematics* K = smart_cast<CKinematics*>(Visual());
K->LL_SetBoneVisible (light_bone, TRUE, TRUE);
K->CalculateBones_Invalidate();
K->CalculateBones ();
}
processing_activate ();
}
void CObjectHandler::reinit (CAI_Stalker *object)
{
inherited::reinit ();
m_hammer_is_clutched = false;
planner().setup (object);
CKinematics *kinematics = smart_cast<CKinematics*>(planner().m_object->Visual());
m_r_hand = kinematics->LL_BoneID(pSettings->r_string(*planner().m_object->cNameSect(),"weapon_bone0"));
m_l_finger1 = kinematics->LL_BoneID(pSettings->r_string(*planner().m_object->cNameSect(),"weapon_bone1"));
m_r_finger2 = kinematics->LL_BoneID(pSettings->r_string(*planner().m_object->cNameSect(),"weapon_bone2"));
m_strap_object_id = ALife::_OBJECT_ID(-1);
m_strap_bone0 = -1;
m_strap_bone1 = -1;
m_clutched_hammer_enabled = false;
}
void CPhysicsShellHolder::UpdateXFORM(const Fmatrix &upd)
{
inherited::UpdateXFORM(upd);
static int method = 1 + 4 + 8; // alpet: набор флагов для отладки, можно менять значение во время выполнения из Watches
if (PPhysicsShell())
{
// m_pPhysicsShell->SetTransform(upd);
if (method & 1)
{
PPhysicsShell()->mXFORM.set(upd);
PPhysicsShell()->SetGlTransformDynamic(upd);
}
if (method & 2)
{ // стянуто из Car.cpp и как-то не так работает
bool enable = PPhysicsShell()->isEnabled();
Fmatrix inv, replace;
Fmatrix restored_form;
PPhysicsShell()->GetGlobalTransformDynamic(&restored_form);
inv.set(restored_form);
inv.invert();
replace.mul(upd, inv);
PPhysicsShell()->SetTransform (replace);
if (enable) PPhysicsShell()->Enable();
else PPhysicsShell()->Disable();
// PPhysicsShell()->GetGlobalTransformDynamic(&XFORM());
}
// пересчет костей
CKinematics *K = PKinematics(Visual());
if (K)
{
K->CalculateBones_Invalidate();
K->CalculateBones();
}
if (method & 4)
PPhysicsShell()->Update();
if (method & 8)
PPhysicsShell()->GetGlobalTransformDynamic(&XFORM());
}
}
CPhysicsShell* P_build_Shell (CGameObject* obj,bool not_active_state,LPCSTR fixed_bones)
{
U16Vec f_bones;
if(fixed_bones){
CKinematics* K = smart_cast<CKinematics*>(obj->Visual());
int count = _GetItemCount(fixed_bones);
for (int i=0 ;i<count; ++i){
string64 fixed_bone;
_GetItem (fixed_bones,i,fixed_bone);
f_bones.push_back(K->LL_BoneID(fixed_bone));
R_ASSERT2(BI_NONE!=f_bones.back(),"wrong fixed bone") ;
}
}
return P_build_Shell (obj,not_active_state,f_bones);
}
void CHelicopter::DieHelicopter()
{
if ( state() == CHelicopter::eDead )
return;
CEntity::Die(NULL);
m_engineSound.stop ();
m_brokenSound.create (pSettings->r_string(*cNameSect(), "broken_snd"),st_Effect,sg_SourceType);
m_brokenSound.play_at_pos (0,XFORM().c,sm_Looped);
CKinematics* K = smart_cast<CKinematics*>(Visual());
if(true /*!PPhysicsShell()*/){
string256 I;
LPCSTR bone;
u16 bone_id;
for (u32 i=0, n=_GetItemCount(*m_death_bones_to_hide); i<n; ++i){
bone = _GetItem(*m_death_bones_to_hide,i,I);
bone_id = K->LL_BoneID (bone);
K->LL_SetBoneVisible(bone_id,FALSE,TRUE);
}
///PPhysicsShell()=P_build_Shell (this,false);
PPhysicsShell()->EnabledCallbacks(TRUE);
PPhysicsShell()->set_ObjectContactCallback(CollisionCallbackDead);
PPhysicsShell()->set_ContactCallback(ContactShotMark);
}
Fvector lin_vel;
Fvector prev_pos = PositionStack.front().vPosition;
lin_vel.sub (XFORM().c,prev_pos);
if(Device.dwTimeGlobal != PositionStack.front().dwTime)
lin_vel.div((Device.dwTimeGlobal-PositionStack.front().dwTime)/1000.0f);
lin_vel.mul (m_death_lin_vel_k);
PPhysicsShell()->set_LinearVel (lin_vel);
PPhysicsShell()->set_AngularVel (m_death_ang_vel);
PPhysicsShell()->Enable ();
K->CalculateBones_Invalidate ();
K->CalculateBones ();
setState (CHelicopter::eDead);
m_engineSound.stop ();
processing_deactivate ();
m_dead = true;
}
void CHelicopter::UpdateMGunDir()
{
CKinematics* K = smart_cast<CKinematics*>(Visual());
m_fire_bone_xform = K->LL_GetTransform(m_fire_bone);
m_fire_bone_xform.mulA_43 (XFORM());
m_fire_pos.set (0,0,0);
m_fire_bone_xform.transform_tiny(m_fire_pos);
m_fire_dir.set (0,0,1);
m_fire_bone_xform.transform_dir(m_fire_dir);
m_fire_dir.sub (m_enemy.destEnemyPos,m_fire_pos).normalize_safe();
m_left_rocket_bone_xform = K->LL_GetTransform(m_left_rocket_bone);
m_left_rocket_bone_xform.mulA_43 (XFORM());
m_left_rocket_bone_xform.c.y += 1.0f;
//.fake
m_right_rocket_bone_xform = K->LL_GetTransform(m_right_rocket_bone);
m_right_rocket_bone_xform.mulA_43 (XFORM());
m_right_rocket_bone_xform.c.y += 1.0f;
//.fake
m_allow_fire = TRUE;
Fmatrix XFi;
XFi.invert (XFORM());
Fvector dep;
XFi.transform_tiny (dep,m_enemy.destEnemyPos);
{// x angle
Fvector A_; A_.sub(dep,m_bind_x); m_i_bind_x_xform.transform_dir(A_); A_.normalize();
m_tgt_rot.x = angle_normalize_signed(m_bind_rot.x-A_.getP());
float sv_x = m_tgt_rot.x;
clamp (m_tgt_rot.x,-m_lim_x_rot.y,-m_lim_x_rot.x);
if (!fsimilar(sv_x,m_tgt_rot.x,EPS_L)) m_allow_fire=FALSE;
}
{// y angle
Fvector A_; A_.sub(dep,m_bind_y); m_i_bind_y_xform.transform_dir(A_); A_.normalize();
m_tgt_rot.y = angle_normalize_signed(m_bind_rot.y-A_.getH());
float sv_y = m_tgt_rot.y;
clamp (m_tgt_rot.y,-m_lim_y_rot.y,-m_lim_y_rot.x);
if (!fsimilar(sv_y,m_tgt_rot.y,EPS_L)) m_allow_fire=FALSE;
}
if ((angle_difference(m_cur_rot.x,m_tgt_rot.x)>deg2rad(m_barrel_dir_tolerance))||
(angle_difference(m_cur_rot.y,m_tgt_rot.y)>deg2rad(m_barrel_dir_tolerance)))
m_allow_fire=FALSE;
}
void fix_bones(LPCSTR fixed_bones,CPhysicsShell* shell )
{
VERIFY(fixed_bones);
VERIFY(shell);
CKinematics *pKinematics = shell->PKinematics();
VERIFY(pKinematics);
int count = _GetItemCount(fixed_bones);
for (int i=0 ;i<count; ++i)
{
string64 fixed_bone ;
_GetItem (fixed_bones,i,fixed_bone) ;
u16 fixed_bone_id=pKinematics->LL_BoneID(fixed_bone) ;
R_ASSERT2(BI_NONE!=fixed_bone_id,"wrong fixed bone") ;
CPhysicsElement* E = shell->get_Element(fixed_bone_id) ;
if(E)
E->Fix();
}
}
void CCarWeapon::UpdateBarrelDir()
{
CKinematics* K = smart_cast<CKinematics*>(m_object->Visual());
m_fire_bone_xform = K->LL_GetTransform(m_fire_bone);
m_fire_bone_xform.mulA_43(m_object->XFORM());
m_fire_pos.set(0,0,0);
m_fire_bone_xform.transform_tiny(m_fire_pos);
m_fire_dir.set(0,0,1);
m_fire_bone_xform.transform_dir(m_fire_dir);
m_fire_norm.set(0,1,0);
m_fire_bone_xform.transform_dir(m_fire_norm);
m_allow_fire = true;
Fmatrix XFi;
XFi.invert (m_object->XFORM());
Fvector dep;
XFi.transform_dir (dep,m_destEnemyDir);
{// x angle
m_i_bind_x_xform.transform_dir(dep); dep.normalize();
m_tgt_x_rot = angle_normalize_signed(m_bind_x_rot-dep.getP());
clamp (m_tgt_x_rot,-m_lim_x_rot.y,-m_lim_x_rot.x);
}
{// y angle
m_i_bind_y_xform.transform_dir(dep); dep.normalize();
m_tgt_y_rot = angle_normalize_signed(m_bind_y_rot-dep.getH());
clamp (m_tgt_y_rot,-m_lim_y_rot.y,-m_lim_y_rot.x);
}
m_cur_x_rot = angle_inertion_var(m_cur_x_rot,m_tgt_x_rot,m_min_gun_speed,m_max_gun_speed,PI,Device.fTimeDelta);
m_cur_y_rot = angle_inertion_var(m_cur_y_rot,m_tgt_y_rot,m_min_gun_speed,m_max_gun_speed,PI,Device.fTimeDelta);
static float dir_eps = deg2rad(5.0f);
if( !fsimilar(m_cur_x_rot,m_tgt_x_rot,dir_eps)|| !fsimilar(m_cur_y_rot,m_tgt_y_rot,dir_eps))
m_allow_fire=FALSE;
#if (0)
if(Device.dwFrame%200==0){
Msg("m_cur_x_rot=[%f]",m_cur_x_rot);
Msg("m_cur_y_rot=[%f]",m_cur_y_rot);
}
#endif
}
void CCar::SWheel::Load(LPCSTR section)
{
CKinematics *K =PKinematics(car->Visual()) ;
CInifile *ini =K->LL_UserData() ;
VERIFY (ini) ;
if(ini->section_exist(section))
{
collision_params.damping_factor =READ_IF_EXISTS(ini,r_float,section,"damping_factor",collision_params.damping_factor);
collision_params.spring_factor =READ_IF_EXISTS(ini,r_float,section,"spring_factor",collision_params.spring_factor);
collision_params.mu_factor =READ_IF_EXISTS(ini,r_float,section,"friction_factor",collision_params.mu_factor);
}
else if(ini->section_exist("wheels_params"))
{
collision_params.damping_factor =ini->r_float("wheels_params","damping_factor") ;
collision_params.spring_factor =ini->r_float("wheels_params","spring_factor") ;
collision_params.mu_factor =ini->r_float("wheels_params","friction_factor") ;
}
}
void CArtefact::UpdateXForm()
{
if (Device.dwFrame!=dwXF_Frame)
{
dwXF_Frame = Device.dwFrame;
if (0==H_Parent()) return;
// Get access to entity and its visual
CEntityAlive* E = smart_cast<CEntityAlive*>(H_Parent());
if(!E) return ;
const CInventoryOwner *parent = smart_cast<const CInventoryOwner*>(E);
if (parent && parent->use_simplified_visual())
return;
VERIFY (E);
CKinematics* V = smart_cast<CKinematics*> (E->Visual());
VERIFY (V);
// Get matrices
int boneL,boneR,boneR2;
E->g_WeaponBones (boneL,boneR,boneR2);
boneL = boneR2;
V->CalculateBones ();
Fmatrix& mL = V->LL_GetTransform(u16(boneL));
Fmatrix& mR = V->LL_GetTransform(u16(boneR));
// Calculate
Fmatrix mRes;
Fvector R,D,N;
D.sub (mL.c,mR.c); D.normalize_safe();
R.crossproduct (mR.j,D); R.normalize_safe();
N.crossproduct (D,R); N.normalize_safe();
mRes.set (R,N,D,mR.c);
mRes.mulA_43 (E->XFORM());
// UpdatePosition (mRes);
XFORM().mul (mRes,offset());
}
}
void CArtefact::OnH_A_Chield()
{
inherited::OnH_A_Chield ();
StopLights();
if (GameID() == GAME_SINGLE)
{
if (*m_sParticlesName)
{
CParticlesPlayer::StopParticles(m_sParticlesName, BI_NONE, true);
}
}
else
{
CKinematics* K = smart_cast<CKinematics*>(H_Parent()->Visual());
if (K)
m_CarringBoneID = K->LL_BoneID("bip01_head");
else
m_CarringBoneID = u16(-1);
}
}
void CGraviArtefact::UpdateCLChild()
{
VERIFY(!ph_world->Processing());
if (getVisible() && m_pPhysicsShell) {
if (m_fJumpHeight) {
Fvector dir;
dir.set(0, -1.f, 0);
collide::rq_result RQ;
//проверить высоту артифакта
if(Level().ObjectSpace.RayPick(Position(), dir, m_fJumpHeight, collide::rqtBoth, RQ, this))
{
dir.y = 1.f;
m_pPhysicsShell->applyImpulse(dir,
30.f * Device.fTimeDelta *
m_pPhysicsShell->getMass());
}
}
} else
if(H_Parent())
{
XFORM().set(H_Parent()->XFORM());
if (GameID() == GAME_ARTEFACTHUNT && m_CarringBoneID != u16(-1))
{
CKinematics* K = smart_cast<CKinematics*>(H_Parent()->Visual());
if (K)
{
K->CalculateBones ();
Fmatrix Ruck_MTX = K->LL_GetTransform(m_CarringBoneID);
Fvector x;
x.set(-0.1f, 0.f, -0.3f);
Ruck_MTX.translate_add(x);
Ruck_MTX.mulA_43 (XFORM());
XFORM().set(Ruck_MTX);
};
};
};
}
void CHelicopter::UpdateHeliParticles ()
{
CKinematics* K = smart_cast<CKinematics*>(Visual());
m_particleXFORM = K->LL_GetTransform(m_smoke_bone);
m_particleXFORM.mulA_43(XFORM());
if (m_pParticle){
Fvector vel;
Fvector last_pos = PositionStack.back().vPosition;
vel.sub(Position(), last_pos);
vel.mul(5.0f);
m_pParticle->UpdateParent(m_particleXFORM, vel );
}
//lighting
if(m_light_render->get_active()){
Fmatrix xf;
Fmatrix& M = K->LL_GetTransform(u16(m_light_bone));
xf.mul (XFORM(),M);
VERIFY(!fis_zero(DET(xf)));
m_light_render->set_rotation (xf.k,xf.i);
m_light_render->set_position (xf.c);
if (m_lanim)
{
int frame;
u32 clr = m_lanim->CalculateBGR(Device.fTimeGlobal,frame); // òþ÷ò¨ð•ðõª ò ¯þ¨üðªõ BGR
Fcolor fclr;
fclr.set ((float)color_get_B(clr),(float)color_get_G(clr),(float)color_get_R(clr),1.f);
fclr.mul_rgb (m_light_brightness/255.f);
m_light_render->set_color (fclr);
}
}
}
void CPhysicObject::AddElement(CPhysicsElement* root_e, int id)
{
CKinematics* K = smart_cast<CKinematics*>(Visual());
CPhysicsElement* E = P_create_Element();
CBoneInstance& B = K->LL_GetBoneInstance(u16(id));
E->mXFORM.set (K->LL_GetTransform(u16(id)));
Fobb bb = K->LL_GetBox(u16(id));
if(bb.m_halfsize.magnitude()<0.05f)
{
bb.m_halfsize.add(0.05f);
}
E->add_Box (bb);
E->setMass (10.f);
E->set_ParentElement(root_e);
B.set_callback (bctPhysics,m_pPhysicsShell->GetBonesCallback(),E);
m_pPhysicsShell->add_Element (E);
if( !(m_type==epotFreeChain && root_e==0) )
{
CPhysicsJoint* J= P_create_Joint(CPhysicsJoint::full_control,root_e,E);
J->SetAnchorVsSecondElement (0,0,0);
J->SetAxisDirVsSecondElement (1,0,0,0);
J->SetAxisDirVsSecondElement (0,1,0,2);
J->SetLimits (-M_PI/2,M_PI/2,0);
J->SetLimits (-M_PI/2,M_PI/2,1);
J->SetLimits (-M_PI/2,M_PI/2,2);
m_pPhysicsShell->add_Joint (J);
}
CBoneData& BD = K->LL_GetData(u16(id));
for (vecBonesIt it=BD.children.begin(); BD.children.end() != it; ++it){
AddElement (E,(*it)->GetSelfID());
}
}
void CScriptGameObject::Hit(CScriptHit *tpLuaHit)
{
CScriptHit &tLuaHit = *tpLuaHit;
NET_Packet P;
SHit HS;
HS.GenHeader(GE_HIT,object().ID()); // object().u_EventGen(P,GE_HIT,object().ID());
THROW2 (tLuaHit.m_tpDraftsman,"Where is hit initiator??!"); // THROW2 (tLuaHit.m_tpDraftsman,"Where is hit initiator??!");
HS.whoID = u16(tLuaHit.m_tpDraftsman->ID()); // P.w_u16 (u16(tLuaHit.m_tpDraftsman->ID()));
HS.weaponID = 0; // P.w_u16 (0);
HS.dir = tLuaHit.m_tDirection; // P.w_dir (tLuaHit.m_tDirection);
HS.power = tLuaHit.m_fPower; // P.w_float (tLuaHit.m_fPower);
CKinematics *V = smart_cast<CKinematics*>(object().Visual()); // CKinematics *V = smart_cast<CKinematics*>(object().Visual());
VERIFY (V); // VERIFY (V);
if (xr_strlen (tLuaHit.m_caBoneName)) // if (xr_strlen (tLuaHit.m_caBoneName))
HS.boneID = (V->LL_BoneID(tLuaHit.m_caBoneName)); // P.w_s16 (V->LL_BoneID(tLuaHit.m_caBoneName));
else // else
HS.boneID = (s16(0)); // P.w_s16 (s16(0));
HS.p_in_bone_space = Fvector().set(0,0,0); // P.w_vec3 (Fvector().set(0,0,0));
HS.impulse = tLuaHit.m_fImpulse; // P.w_float (tLuaHit.m_fImpulse);
HS.hit_type = (ALife::EHitType)(tLuaHit.m_tHitType); // P.w_u16 (u16(tLuaHit.m_tHitType));
HS.Write_Packet(P);
object().u_EventSend(P);
}
void CStalkerAnimationManager::assign_bone_callbacks ()
{
CKinematics *kinematics = smart_cast<CKinematicsAnimated*>(m_visual);
VERIFY (kinematics);
LPCSTR section = *object().cNameSect();
int head_bone = kinematics->LL_BoneID(pSettings->r_string(section,"bone_head"));
kinematics->LL_GetBoneInstance (u16(head_bone)).set_callback(bctCustom,&head::callback,&object());
int shoulder_bone = kinematics->LL_BoneID(pSettings->r_string(section,"bone_shoulder"));
kinematics->LL_GetBoneInstance (u16(shoulder_bone)).set_callback(bctCustom,&shoulder::callback,&object());
int spin_bone = kinematics->LL_BoneID(pSettings->r_string(section,"bone_spin"));
kinematics->LL_GetBoneInstance (u16(spin_bone)).set_callback(bctCustom,&spine::callback,&object());
}
