void CKinematics::DebugRender(Fmatrix& XFORM)
{
CalculateBones ();
CBoneData::BoneDebug dbgLines;
(*bones)[iRoot]->DebugQuery (dbgLines);
Fvector Z; Z.set(0,0,0);
Fvector H1; H1.set(0.01f,0.01f,0.01f);
Fvector H2; H2.mul(H1,2);
for (u32 i=0; i<dbgLines.size(); i+=2) {
Fmatrix& M1 = bone_instances[dbgLines[i]].mTransform;
Fmatrix& M2 = bone_instances[dbgLines[i+1]].mTransform;
Fvector P1,P2;
M1.transform_tiny(P1,Z);
M2.transform_tiny(P2,Z);
RCache.dbg_DrawLINE(XFORM,P1,P2,D3DCOLOR_XRGB(0,255,0));
Fmatrix M;
M.mul_43(XFORM,M2);
RCache.dbg_DrawOBB(M,H1,D3DCOLOR_XRGB(255,255,255));
RCache.dbg_DrawOBB(M,H2,D3DCOLOR_XRGB(255,255,255));
}
for (u32 b=0; b<bones->size(); b++)
{
Fobb& obb = (*bones)[b]->obb;
Fmatrix& Mbone = bone_instances[b].mTransform;
Fmatrix Mbox; obb.xform_get(Mbox);
Fmatrix X; X.mul(Mbone,Mbox);
Fmatrix W; W.mul(XFORM,X);
RCache.dbg_DrawOBB(W,obb.m_halfsize,D3DCOLOR_XRGB(0,0,255));
}
}
void CHangingLamp::UpdateCL ()
{
inherited::UpdateCL ();
if(m_pPhysicsShell)
m_pPhysicsShell->InterpolateGlobalTransform(&XFORM());
if (Alive() && light_render->get_active()){
if(Visual()) PKinematics(Visual())->CalculateBones();
// update T&R from light (main) bone
Fmatrix xf;
if (light_bone!=BI_NONE){
Fmatrix& M = smart_cast<CKinematics*>(Visual())->LL_GetTransform(light_bone);
xf.mul (XFORM(),M);
VERIFY(!fis_zero(DET(xf)));
}else{
xf.set (XFORM());
}
light_render->set_rotation (xf.k,xf.i);
light_render->set_position (xf.c);
if (glow_render)glow_render->set_position (xf.c);
// update T&R from ambient bone
if (light_ambient){
if (ambient_bone!=light_bone){
if (ambient_bone!=BI_NONE){
Fmatrix& M = smart_cast<CKinematics*>(Visual())->LL_GetTransform(ambient_bone);
xf.mul (XFORM(),M);
VERIFY(!fis_zero(DET(xf)));
}else{
xf.set (XFORM());
}
}
light_ambient->set_rotation (xf.k,xf.i);
light_ambient->set_position (xf.c);
}
if (lanim){
int frame;
u32 clr = 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 (fBrightness/255.f);
light_render->set_color (fclr);
if (glow_render) glow_render->set_color (fclr);
if (light_ambient) {
fclr.mul_rgb (ambient_power);
light_ambient->set_color(fclr);
}
}
}
}
float CBaseMonster::get_screen_space_coverage_diagonal()
{
Fbox b = Visual()->getVisData().box;
Fmatrix xform;
xform.mul (Device.mFullTransform,XFORM());
Fvector2 mn ={flt_max,flt_max},mx={flt_min,flt_min};
for (u32 k=0; k<8; ++k)
{
Fvector p;
b.getpoint (k,p);
xform.transform (p);
mn.x = _min(mn.x,p.x);
mn.y = _min(mn.y,p.y);
mx.x = _max(mx.x,p.x);
mx.y = _max(mx.y,p.y);
}
float const width = mx.x - mn.x;
float const height = mx.y - mn.y;
float const average_diagonal = _sqrt(width * height);
return average_diagonal;
}
void CActor::PickupInfoDraw(CObject* object)
{
LPCSTR draw_str = NULL;
CInventoryItem* item = smart_cast<CInventoryItem*>(object);
if(!item) return;
Fmatrix res;
res.mul (Device.mFullTransform,object->XFORM());
Fvector4 v_res;
Fvector shift;
draw_str = item->NameItem();
shift.set(0,0,0);
res.transform(v_res,shift);
if (v_res.z < 0 || v_res.w < 0) return;
if (v_res.x < -1.f || v_res.x > 1.f || v_res.y<-1.f || v_res.y>1.f) return;
float x = (1.f + v_res.x)/2.f * (Device.dwWidth);
float y = (1.f - v_res.y)/2.f * (Device.dwHeight);
UI().Font().pFontLetterica16Russian->SetAligment (CGameFont::alCenter);
UI().Font().pFontLetterica16Russian->SetColor (PICKUP_INFO_COLOR);
UI().Font().pFontLetterica16Russian->Out (x,y,draw_str);
}
void CUIArtefactDetectorElite::GetUILocatorMatrix(Fmatrix& _m)
{
Fmatrix trans = m_parent->HudItemData()->m_item_transform;
u16 bid = m_parent->HudItemData()->m_model->LL_BoneID("cover");
Fmatrix cover_bone = m_parent->HudItemData()->m_model->LL_GetTransform(bid);
_m.mul (trans, cover_bone);
_m.mulB_43 (m_map_attach_offset);
}
//sclale base' * q by scale_factor returns result in matrix m_res
IC void q_scale_vs_basem(Fmatrix &m_res,const Fquaternion &q, const Fquaternion &base,float scale_factor)
{
Fmatrix mb,imb;
mb.rotation(base);
imb.invert(mb);
Fmatrix m;m.rotation(q);
m_res.mul(imb,m);
q_scalem(m_res,scale_factor);
}
void SCarLight::Update()
{
VERIFY(!ph_world->Processing());
if(!isOn()) return;
CCar* pcar=m_holder->PCar();
CBoneInstance& BI = smart_cast<IKinematics*>(pcar->Visual())->LL_GetBoneInstance(bone_id);
Fmatrix M;
M.mul(pcar->XFORM(),BI.mTransform);
light_render->set_rotation (M.k,M.i);
glow_render->set_direction(M.k);
glow_render->set_position (M.c);
light_render->set_position (M.c);
}
// 2D texgen (texture adjustment matrix)
void CRenderTarget::u_compute_texgen_screen (Fmatrix& m_Texgen)
{
float _w = float(Device.dwWidth);
float _h = float(Device.dwHeight);
float o_w = (.5f / _w);
float o_h = (.5f / _h);
Fmatrix m_TexelAdjust =
{
0.5f, 0.0f, 0.0f, 0.0f,
0.0f, -0.5f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.5f + o_w, 0.5f + o_h, 0.0f, 1.0f
};
m_Texgen.mul (m_TexelAdjust,RCache.xforms.m_wvp);
}
//----------------------------------------------------------------------------
// Skeleton functions
//----------------------------------------------------------------------------
bool CEditableObject::ImportMAXSkeleton(CExporter* E)
{
bool bResult = true;
CEditableMesh* MESH = xr_new<CEditableMesh>(this);
m_Meshes.push_back(MESH);
// import mesh
if (!MESH->Convert(E)) return FALSE;
// BONES
m_Bones.reserve(E->m_Bones.size());
for (int B=0; B!=E->m_Bones.size(); B++){
m_Bones.push_back(xr_new<CBone>());
CBone* BONE = m_Bones.back();
CBoneDef* bone = E->m_Bones[B];
CBoneDef* parent_bone = bone->parent;
Fvector offset,rotate;
float length= 0.1f;
Fmatrix m;
if (parent_bone) m.mul(parent_bone->matOffset,bone->matInit);
else m.set(bone->matInit);
m.getXYZi (rotate);
offset.set (m.c);
BONE->SetWMap (bone->name.c_str());
BONE->SetName (bone->name.c_str());
BONE->SetParentName (Helper::ConvertSpace(string(bone->pBone->GetParentNode()->GetName())).c_str());
BONE->SetRestParams (length,offset,rotate);
}
// DEFAULT BONE PART
m_BoneParts.push_back(SBonePart());
SBonePart& BP = m_BoneParts.back();
BP.alias = "default";
for (int b_i=0; b_i<(int)m_Bones.size(); b_i++)
BP.bones.push_back(Bones()[b_i]->Name());
m_objectFlags.set(CEditableObject::eoDynamic,TRUE);
if ((0==GetVertexCount())||(0==GetFaceCount())){
bResult = false;
}else{
ELog.Msg(mtInformation,"Model '%s' contains: %d points, %d faces, %d bones", E->m_MeshNode->GetName(), GetVertexCount(), GetFaceCount(), Bones().size());
}
return bResult;
}
void CActor::RenderText (LPCSTR Text, Fvector dpos, float* pdup, u32 color)
{
if (!g_Alive()) return;
CBoneInstance& BI = smart_cast<CKinematics*>(Visual())->LL_GetBoneInstance(u16(m_head));
Fmatrix M;
smart_cast<CKinematics*>(Visual())->CalculateBones ();
M.mul (XFORM(),BI.mTransform);
//------------------------------------------------
Fvector v0, v1;
v0.set(M.c); v1.set(M.c);
Fvector T = Device.vCameraTop;
v1.add(T);
Fvector v0r, v1r;
Device.mFullTransform.transform(v0r,v0);
Device.mFullTransform.transform(v1r,v1);
float size = v1r.distance_to(v0r);
CGameFont* pFont = HUD().Font().pFontArial14;
if (!pFont) return;
// float OldFontSize = pFont->GetHeight ();
float delta_up = 0.0f;
if (size < mid_size) delta_up = upsize;
else delta_up = upsize*(mid_size/size);
dpos.y += delta_up;
if (size > mid_size) size = mid_size;
// float NewFontSize = size/mid_size * fontsize;
//------------------------------------------------
M.c.y += dpos.y;
Fvector4 v_res;
Device.mFullTransform.transform(v_res,M.c);
if (v_res.z < 0 || v_res.w < 0) return;
if (v_res.x < -1.f || v_res.x > 1.f || v_res.y<-1.f || v_res.y>1.f) return;
float x = (1.f + v_res.x)/2.f * (Device.dwWidth);
float y = (1.f - v_res.y)/2.f * (Device.dwHeight);
pFont->SetAligment (CGameFont::alCenter);
pFont->SetColor (color);
// pFont->SetHeight (NewFontSize);
pFont->Out (x,y,Text);
//-------------------------------------------------
// pFont->SetHeight(OldFontSize);
*pdup = delta_up;
};
void CLevelDebug::draw_object_info()
{
// handle all of the objects
for (OBJECT_INFO_MAP_IT it = m_objects_info.begin(); it != m_objects_info.end(); ++it) {
// если объект невалидный - удалить информацию
if (!it->first || it->first->getDestroy()) {
for (CLASS_INFO_MAP_IT it_class = it->second.begin(); it_class != it->second.end(); ++it_class){
xr_delete(it_class->second);
}
m_objects_info.erase(it);
break;
}
Fmatrix res;
res.mul (Device.mFullTransform,it->first->XFORM());
Fvector4 v_res;
float delta_height = 0.f;
// handle all of the classes
for (CLASS_INFO_MAP_IT class_it = it->second.begin(); class_it != it->second.end(); ++class_it) {
// get up on 2 meters
res.transform(v_res, class_it->second->get_shift_pos());
// check if the object in sight
if (v_res.z < 0 || v_res.w < 0) continue;
if (v_res.x < -1.f || v_res.x > 1.f || v_res.y<-1.f || v_res.y>1.f) continue;
// get real (x,y)
float x = (1.f + v_res.x)/2.f * (Device.dwWidth);
float y = (1.f - v_res.y)/2.f * (Device.dwHeight) - delta_height;
float start_y = y;
// handle all of the text inside class
class_it->second->draw_info(x,y);
delta_height = start_y - y;
}
}
}
void CActor::RenderIndicator (Fvector dpos, float r1, float r2, ref_shader IndShader)
{
if (!g_Alive()) return;
u32 dwOffset = 0,dwCount = 0;
FVF::LIT* pv_start = (FVF::LIT*)RCache.Vertex.Lock(4,hFriendlyIndicator->vb_stride,dwOffset);
FVF::LIT* pv = pv_start;
// base rect
CBoneInstance& BI = smart_cast<CKinematics*>(Visual())->LL_GetBoneInstance(u16(m_head));
Fmatrix M;
smart_cast<CKinematics*>(Visual())->CalculateBones ();
M.mul (XFORM(),BI.mTransform);
Fvector pos = M.c; pos.add(dpos);
const Fvector& T = Device.vCameraTop;
const Fvector& R = Device.vCameraRight;
Fvector Vr, Vt;
Vr.x = R.x*r1;
Vr.y = R.y*r1;
Vr.z = R.z*r1;
Vt.x = T.x*r2;
Vt.y = T.y*r2;
Vt.z = T.z*r2;
Fvector a,b,c,d;
a.sub (Vt,Vr);
b.add (Vt,Vr);
c.invert (a);
d.invert (b);
pv->set (d.x+pos.x,d.y+pos.y,d.z+pos.z, 0xffffffff, 0.f,1.f); pv++;
pv->set (a.x+pos.x,a.y+pos.y,a.z+pos.z, 0xffffffff, 0.f,0.f); pv++;
pv->set (c.x+pos.x,c.y+pos.y,c.z+pos.z, 0xffffffff, 1.f,1.f); pv++;
pv->set (b.x+pos.x,b.y+pos.y,b.z+pos.z, 0xffffffff, 1.f,0.f); pv++;
// render
dwCount = u32(pv-pv_start);
RCache.Vertex.Unlock (dwCount,hFriendlyIndicator->vb_stride);
RCache.set_xform_world (Fidentity);
RCache.set_Shader (IndShader);
RCache.set_Geometry (hFriendlyIndicator);
RCache.Render (D3DPT_TRIANGLESTRIP,dwOffset,0, dwCount, 0, 2);
};
// 2D texgen for jitter (texture adjustment matrix)
void CRenderTarget::u_compute_texgen_jitter (Fmatrix& m_Texgen_J)
{
// place into 0..1 space
Fmatrix m_TexelAdjust =
{
0.5f, 0.0f, 0.0f, 0.0f,
0.0f, -0.5f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.0f, 1.0f
};
m_Texgen_J.mul (m_TexelAdjust,RCache.xforms.m_wvp);
// rescale - tile it
float scale_X = float(Device.dwWidth) / float(TEX_jitter);
float scale_Y = float(Device.dwHeight)/ float(TEX_jitter);
float offset = (.5f / float(TEX_jitter));
m_TexelAdjust.scale (scale_X, scale_Y,1.f );
m_TexelAdjust.translate_over(offset, offset, 0 );
m_Texgen_J.mulA_44 (m_TexelAdjust);
}
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);
}
}
}
BOOL CMonsterEffectorHit::ProcessCam(SCamEffectorInfo& info)
{
fLifeTime -= Device.fTimeDelta;
if(fLifeTime<0) return FALSE;
// процент оставшегос¤ времени
float time_left_perc = fLifeTime / total;
// »нициализаци¤
Fmatrix Mdef;
Mdef.identity ();
Mdef.j.set (info.n);
Mdef.k.set (info.d);
Mdef.i.crossproduct (info.n,info.d);
Mdef.c.set (info.p);
float period_all = period_number * PI_MUL_2; // макс. значение цикла
float cur_amp = max_amp * (PI / 180) * time_left_perc;
Fvector dangle;
dangle.x = cur_amp/offset.x * _sin(period_all/offset.x * (1.0f - time_left_perc));
dangle.y = cur_amp/offset.y * _cos(period_all/offset.y * (1.0f - time_left_perc));
dangle.z = cur_amp/offset.z * _sin(period_all/offset.z * (1.0f - time_left_perc));
// ”становить углы смещени¤
Fmatrix R;
R.setHPB (dangle.x,dangle.y,dangle.z);
Fmatrix mR;
mR.mul (Mdef,R);
info.d.set (mR.k);
info.n.set (mR.j);
return TRUE;
}
BOOL CPseudogigantStepEffector::Process(Fvector &p, Fvector &d, Fvector &n, float& fFov, float& fFar, float& fAspect)
{
fLifeTime -= Device.fTimeDelta; if(fLifeTime<0) return FALSE;
// процент оставшегос¤ времени
float time_left_perc = fLifeTime / total;
// »нициализаци¤
Fmatrix Mdef;
Mdef.identity ();
Mdef.j.set (n);
Mdef.k.set (d);
Mdef.i.crossproduct (n,d);
Mdef.c.set (p);
float period_all = period_number * PI_MUL_2; // макс. значение цикла
float k = 1 - time_left_perc + EPS_L + (1 - power);
float cur_amp = max_amp * (PI / 180) / (10 * k * k);
Fvector dangle;
dangle.x = cur_amp/2 * _sin(period_all * (1.0f - time_left_perc));
dangle.y = cur_amp * _cos(period_all/2 * (1.0f - time_left_perc));
dangle.z = cur_amp/4 * _sin(period_all/4 * (1.0f - time_left_perc));
// ”становить углы смещени¤
Fmatrix R;
R.setHPB (dangle.x,dangle.y,dangle.z);
Fmatrix mR;
mR.mul (Mdef,R);
d.set (mR.k);
n.set (mR.j);
return TRUE;
}
void CDrawUtilities::DrawCone (const Fmatrix& parent, const Fvector& apex, const Fvector& dir, float height, float radius, u32 clr_s, u32 clr_w, BOOL bSolid, BOOL bWire)
{
Fmatrix mScale;
mScale.scale (2.f*radius,2.f*radius,height);
// build final rotation / translation
Fvector L_dir,L_up,L_right;
L_dir.set (dir); L_dir.normalize ();
L_up.set (0,1,0); if (_abs(L_up.dotproduct(L_dir))>.99f) L_up.set(0,0,1);
L_right.crossproduct(L_up,L_dir); L_right.normalize ();
L_up.crossproduct (L_dir,L_right); L_up.normalize ();
Fmatrix mR;
mR.i = L_right; mR._14 = 0;
mR.j = L_up; mR._24 = 0;
mR.k = L_dir; mR._34 = 0;
mR.c = apex; mR._44 = 1;
// final xform
Fmatrix xf; xf.mul (mR,mScale);
xf.mulA_43 (parent);
RCache.set_xform_world(xf);
DrawIdentCone (bSolid,bWire,clr_s,clr_w);
}
void ESoundEnvironment::get_box(Fmatrix& m)
{
CShapeData::shape_def shape = get_shape(0);
R_ASSERT(shape.type==CShapeData::cfBox);
m.mul (_Transform(),shape.data.box);
}
void CLightProjector::calculate ()
{
#ifdef _GPA_ENABLED
TAL_SCOPED_TASK_NAMED( "CLightProjector::calculate()" );
#endif // _GPA_ENABLED
if (receivers.empty()) return;
// perform validate / markup
for (u32 r_it=0; r_it<receivers.size(); r_it++)
{
// validate
BOOL bValid = TRUE;
IRenderable* O = receivers[r_it];
CROS_impl* LT = (CROS_impl*)O->renderable_ROS();
int slot = LT->shadow_recv_slot;
if (slot<0 || slot>=P_o_count) bValid = FALSE; // invalid slot
else if (cache[slot].O!=O) bValid = FALSE; // not the same object
else {
// seems to be valid
Fbox bb; bb.xform (O->renderable.visual->getVisData().box,O->renderable.xform);
if (cache[slot].BB.contains(bb)) {
// inside, but maybe timelimit exceeded?
if (Device.dwTimeGlobal > cache[slot].dwTimeValid) bValid = FALSE; // timeout
} else bValid = FALSE; // out of bounds
}
//
if (bValid) {
// Ok, use cached version
cache[slot].dwFrame = Device.dwFrame;
} else {
taskid.push_back (r_it);
}
}
if (taskid.empty()) return;
// Begin
Device.Statistic->RenderDUMP_Pcalc.Begin ();
RCache.set_RT (RT->pRT);
RCache.set_ZB (RImplementation.Target->pTempZB);
CHK_DX(HW.pDevice->Clear (0,0, D3DCLEAR_ZBUFFER | (HW.Caps.bStencil?D3DCLEAR_STENCIL:0), 0,1,0 ));
RCache.set_xform_world (Fidentity);
// reallocate/reassociate structures + perform all the work
for (u32 c_it=0; c_it<cache.size(); c_it++)
{
if (taskid.empty()) break;
if (Device.dwFrame==cache[c_it].dwFrame) continue;
// found not used slot
int tid = taskid.back(); taskid.pop_back();
recv& R = cache [c_it];
IRenderable* O = receivers [tid];
const vis_data& vis = O->renderable.visual->getVisData();
CROS_impl* LT = (CROS_impl*)O->renderable_ROS();
VERIFY2 (_valid(O->renderable.xform),"Invalid object transformation");
VERIFY2 (_valid(vis.sphere.P),"Invalid object's visual sphere");
Fvector C; O->renderable.xform.transform_tiny (C,vis.sphere.P);
R.O = O;
R.C = C;
R.C.y += vis.sphere.R*0.1f; //. YURA: 0.1 can be more
R.BB.xform (vis.box,O->renderable.xform).scale(0.1f);
R.dwTimeValid = Device.dwTimeGlobal + ::Random.randI(time_min,time_max);
LT->shadow_recv_slot = c_it;
// Msg ("[%f,%f,%f]-%f",C.C.x,C.C.y,C.C.z,C.O->renderable.visual->vis.sphere.R);
// calculate projection-matrix
Fmatrix mProject;
float p_R = R.O->renderable.visual->getVisData().sphere.R * 1.1f;
//VERIFY2 (p_R>EPS_L,"Object has no physical size");
VERIFY3 (p_R>EPS_L,"Object has no physical size", R.O->renderable.visual->getDebugName().c_str());
float p_hat = p_R/P_cam_dist;
float p_asp = 1.f;
float p_near = P_cam_dist-EPS_L;
float p_far = P_cam_dist+p_R+P_cam_range;
mProject.build_projection_HAT (p_hat,p_asp,p_near,p_far);
RCache.set_xform_project (mProject);
// calculate view-matrix
Fmatrix mView;
Fvector v_C, v_Cs, v_N;
v_C.set (R.C);
v_Cs = v_C;
v_C.y += P_cam_dist;
v_N.set (0,0,1);
VERIFY (_valid(v_C) && _valid(v_Cs) && _valid(v_N));
// validate
Fvector v;
v.sub (v_Cs,v_C);;
#ifdef DEBUG
if ((v.x*v.x+v.y*v.y+v.z*v.z)<=flt_zero) {
CObject* OO = dynamic_cast<CObject*>(R.O);
Msg("Object[%s] Visual[%s] has invalid position. ",*OO->cName(),*OO->cNameVisual());
Fvector cc;
OO->Center(cc);
Log("center=",cc);
Log("visual_center=",OO->Visual()->getVisData().sphere.P);
Log("full_matrix=",OO->XFORM());
Log ("v_N",v_N);
Log ("v_C",v_C);
Log ("v_Cs",v_Cs);
Log("all bones transform:--------");
CKinematics* K = dynamic_cast<CKinematics*>(OO->Visual());
for(u16 ii=0; ii<K->LL_BoneCount();++ii){
Fmatrix tr;
tr = K->LL_GetTransform(ii);
Log("bone ",K->LL_BoneName_dbg(ii));
Log("bone_matrix",tr);
}
Log("end-------");
}
#endif
// handle invalid object-bug
if ((v.x*v.x+v.y*v.y+v.z*v.z)<=flt_zero) {
// invalidate record, so that object will be unshadowed, but doesn't crash
R.dwTimeValid = Device.dwTimeGlobal;
LT->shadow_recv_frame = Device.dwFrame-1;
LT->shadow_recv_slot = -1;
continue ;
}
mView.build_camera (v_C,v_Cs,v_N);
RCache.set_xform_view (mView);
// Select slot, set viewport
int s_x = c_it%P_o_line;
int s_y = c_it/P_o_line;
D3DVIEWPORT9 VP = {s_x*P_o_size,s_y*P_o_size,P_o_size,P_o_size,0,1 };
CHK_DX (HW.pDevice->SetViewport(&VP));
// Clear color to ambience
Fvector& cap = LT->get_approximate();
CHK_DX (HW.pDevice->Clear(0,0, D3DCLEAR_TARGET, color_rgba_f(cap.x,cap.y,cap.z, (cap.x+cap.y+cap.z)/4.f), 1, 0 ));
// calculate uv-gen matrix and clamper
Fmatrix mCombine; mCombine.mul (mProject,mView);
Fmatrix mTemp;
float fSlotSize = float(P_o_size)/float(P_rt_size);
float fSlotX = float(s_x*P_o_size)/float(P_rt_size);
float fSlotY = float(s_y*P_o_size)/float(P_rt_size);
float fTexelOffs = (.5f / P_rt_size);
Fmatrix m_TexelAdjust =
{
0.5f/*x-scale*/, 0.0f, 0.0f, 0.0f,
0.0f, -0.5f/*y-scale*/, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f/*z-range*/, 0.0f,
0.5f/*x-bias*/, 0.5f + fTexelOffs/*y-bias*/, 0.0f/*z-bias*/, 1.0f
};
R.UVgen.mul (m_TexelAdjust,mCombine);
mTemp.scale (fSlotSize,fSlotSize,1);
R.UVgen.mulA_44 (mTemp);
mTemp.translate (fSlotX+fTexelOffs,fSlotY+fTexelOffs,0);
R.UVgen.mulA_44 (mTemp);
// Build bbox and render
Fvector min,max;
Fbox BB;
min.set (R.C.x-p_R, R.C.y-(p_R+P_cam_range), R.C.z-p_R);
max.set (R.C.x+p_R, R.C.y+0, R.C.z+p_R);
BB.set (min,max);
R.UVclamp_min.set (min).add (.05f); // shrink a little
R.UVclamp_max.set (max).sub (.05f); // shrink a little
ISpatial* spatial = dynamic_cast<ISpatial*> (O);
if (spatial) {
spatial->spatial_updatesector ();
if (spatial->spatial.sector) RImplementation.r_dsgraph_render_R1_box (spatial->spatial.sector,BB,SE_R1_LMODELS);
}
//if (spatial) RImplementation.r_dsgraph_render_subspace (spatial->spatial.sector,mCombine,v_C,FALSE);
}
// Blur
/*
{
// Fill vertex buffer
u32 Offset;
FVF::TL4uv* pv = (FVF::TL4uv*) RCache.Vertex.Lock (4,geom_Blur.stride(),Offset);
RImplementation.ApplyBlur4 (pv,P_rt_size,P_rt_size,P_blur_kernel);
RCache.Vertex.Unlock (4,geom_Blur.stride());
// Actual rendering (pass0, temp2real)
RCache.set_RT (RT->pRT);
RCache.set_ZB (NULL);
RCache.set_Shader (sh_BlurTR );
RCache.set_Geometry (geom_Blur );
RCache.Render (D3DPT_TRIANGLELIST,Offset,0,4,0,2);
}
*/
// Finita la comedia
Device.Statistic->RenderDUMP_Pcalc.End ();
RCache.set_xform_project (Device.mProject);
RCache.set_xform_view (Device.mView);
}
BOOL CEffectorBobbing::Process (Fvector &p, Fvector &d, Fvector &n, float& /**fFov/**/, float& /**fFar/**/, float& /**fAspect/**/)
{
fTime += Device.fTimeDelta;
if (dwMState&ACTOR_DEFS::mcAnyMove){
if (fReminderFactor<1.f) fReminderFactor += SPEED_REMINDER*Device.fTimeDelta;
else fReminderFactor = 1.f;
}else{
if (fReminderFactor>0.f) fReminderFactor -= SPEED_REMINDER*Device.fTimeDelta;
else fReminderFactor = 0.f;
}
if (!fsimilar(fReminderFactor,0)){
Fmatrix M;
M.identity ();
M.j.set (n);
M.k.set (d);
M.i.crossproduct(n,d);
M.c.set (p);
// apply footstep bobbing effect
Fvector dangle;
float k = ((dwMState& ACTOR_DEFS::mcCrouch)?CROUCH_FACTOR:1.f);
float A, ST;
if(isActorAccelerated(dwMState, m_bZoomMode))
{
A = m_fAmplitudeRun*k;
ST = m_fSpeedRun*fTime*k;
}
else if(is_limping)
{
A = m_fAmplitudeLimp*k;
ST = m_fSpeedLimp*fTime*k;
}
else
{
A = m_fAmplitudeWalk*k;
ST = m_fSpeedWalk*fTime*k;
}
float _sinA = _abs(_sin(ST)*A)*fReminderFactor;
float _cosA = _cos(ST)*A*fReminderFactor;
p.y += _sinA;
dangle.x = _cosA;
dangle.z = _cosA;
dangle.y = _sinA;
Fmatrix R;
R.setHPB (dangle.x,dangle.y,dangle.z);
Fmatrix mR;
mR.mul (M,R);
d.set (mR.k);
n.set (mR.j);
}
// else{
// fTime = 0;
// }
return TRUE;
}
BOOL CAlienEffector::ProcessCam(SCamEffectorInfo& info)
{
// »нициализаци¤
Fmatrix Mdef;
Mdef.identity ();
Mdef.j.set (info.n);
Mdef.k.set (info.d);
Mdef.i.crossproduct (info.n, info.d);
Mdef.c.set (info.p);
// set angle
if (angle_lerp(dangle_current.x, dangle_target.x, ANGLE_SPEED, Device.fTimeDelta)) {
dangle_target.x = angle_normalize(Random.randFs(DELTA_ANGLE_X));
}
if (angle_lerp(dangle_current.y, dangle_target.y, ANGLE_SPEED, Device.fTimeDelta)) {
dangle_target.y = angle_normalize(Random.randFs(DELTA_ANGLE_Y));
}
if (angle_lerp(dangle_current.z, dangle_target.z, ANGLE_SPEED, Device.fTimeDelta)) {
dangle_target.z = angle_normalize(Random.randFs(DELTA_ANGLE_Z));
}
// update inertion
Fmatrix cur_matrix;
cur_matrix.k = monster->Direction();
cur_matrix.c = get_head_position(monster);
float rel_dist = m_prev_eye_matrix.c.distance_to(cur_matrix.c) / MAX_CAMERA_DIST;
clamp (rel_dist, 0.f, 1.f);
def_lerp(m_inertion, 1 - rel_dist, rel_dist, Device.fTimeDelta);
// set pos and dir with inertion
m_prev_eye_matrix.c.inertion(cur_matrix.c, m_inertion);
m_prev_eye_matrix.k.inertion(cur_matrix.k, m_inertion);
Fvector::generate_orthonormal_basis_normalized(m_prev_eye_matrix.k,m_prev_eye_matrix.j,m_prev_eye_matrix.i);
// apply position and direction
Mdef = m_prev_eye_matrix;
//set fov
float rel_speed = monster->m_fCurSpeed / 15.f;
clamp (rel_speed,0.f,1.f);
float m_target_fov = MIN_FOV + (MAX_FOV-MIN_FOV) * rel_speed;
def_lerp(m_current_fov, m_target_fov, FOV_SPEED, Device.fTimeDelta);
info.fFov = m_current_fov;
//////////////////////////////////////////////////////////////////////////
// ”становить углы смещени¤
Fmatrix R;
R.setHPB (dangle_current.x,dangle_current.y,dangle_current.z);
Fmatrix mR;
mR.mul (Mdef,R);
info.d.set (mR.k);
info.n.set (mR.j);
info.p.set (mR.c);
return TRUE;
}
void player_hud::calc_transform(u16 attach_slot_idx, const Fmatrix& offset, Fmatrix& result)
{
Fmatrix ancor_m = m_model->dcast_PKinematics()->LL_GetTransform(m_ancors[attach_slot_idx]);
result.mul (m_transform, ancor_m);
result.mulB_43 (offset);
}
void CEditableObject::RenderBones(const Fmatrix& parent)
{
if (IsSkeleton()){
// render
BoneVec& lst = m_Bones;
for(BoneIt b_it=lst.begin(); b_it!=lst.end(); b_it++){
Device.SetShader(Device.m_WireShader);
RCache.set_xform_world(parent);
Fmatrix& M = (*b_it)->_LTransform();
Fvector p1 = M.c;
u32 c_joint = (*b_it)->flags.is(CBone::flSelected)?color_bone_sel_color:color_bone_norm_color;
if (EPrefs->object_flags.is(epoDrawJoints))
DU_impl.DrawJoint (p1,joint_size,c_joint);
// center of mass
if ((*b_it)->shape.type!=SBoneShape::stNone){
Fvector cm;
M.transform_tiny(cm,(*b_it)->center_of_mass);
if ((*b_it)->flags.is(CBone::flSelected)){
float sz = joint_size*2.f;
DU_impl.DrawCross (cm, sz,sz,sz, sz,sz,sz, 0xFFFFFFFF, false);
DU_impl.DrawRomboid (cm,joint_size*0.7f,color_bone_sel_cm);
}else{
DU_impl.DrawRomboid (cm,joint_size*0.7f,color_bone_norm_cm);
}
}
/*
if (0){
M.transform_dir (d);
p2.mad (p1,d,(*b_it)->_Length());
DU.DrawLine (p1,p2,c_joint);
}
*/
if ((*b_it)->Parent()){
Device.SetShader(Device.m_SelectionShader);
Fvector& p2 = (*b_it)->Parent()->_LTransform().c;
DU_impl.DrawLine (p1,p2,color_bone_link_color);
}
if (EPrefs->object_flags.is(epoDrawBoneAxis)){
Fmatrix mat; mat.mul(parent,M);
DU_impl.DrawObjectAxis(mat,0.03f,(*b_it)->flags.is(CBone::flSelected));
}
if (EPrefs->object_flags.is(epoDrawBoneNames)){
parent.transform_tiny(p1);
u32 c = (*b_it)->flags.is(CBone::flSelected)?0xFFFFFFFF:0xFF000000;
u32 s = (*b_it)->flags.is(CBone::flSelected)?0xFF000000:0xFF909090;
DU_impl.OutText(p1,(*b_it)->Name().c_str(),c,s);
}
if (EPrefs->object_flags.is(epoDrawBoneShapes)){
Device.SetShader(Device.m_SelectionShader);
Fmatrix mat = M;
mat.mulA_43 (parent);
u32 c = (*b_it)->flags.is(CBone::flSelected)?0x80ffffff:0x300000ff;
if ((*b_it)->shape.Valid()){
switch ((*b_it)->shape.type){
case SBoneShape::stBox: DU_impl.DrawOBB (mat,(*b_it)->shape.box,c,c); break;
case SBoneShape::stSphere: DU_impl.DrawSphere (mat,(*b_it)->shape.sphere,c,c,TRUE,TRUE);break;
case SBoneShape::stCylinder:DU_impl.DrawCylinder (mat,(*b_it)->shape.cylinder.m_center,(*b_it)->shape.cylinder.m_direction,(*b_it)->shape.cylinder.m_height,(*b_it)->shape.cylinder.m_radius,c,c,TRUE,TRUE);break;
}
}
}
}
}
}
